Repository: BioSTEAMDevelopmentGroup/biosteam (language: python)

Issue:
Annotations



Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 7da8d07b0..824fc1e25 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,3 +68,4 @@ docs/_templates/*
 ehthumbs.db
 Thumbs.db
 surfaces
+CoolPropFluids*.json
diff --git a/.readthedocs.yml b/.readthedocs.yml
index 55f00595d..2f0325e71 100644
--- a/.readthedocs.yml
+++ b/.readthedocs.yml
@@ -1,8 +1,24 @@
 # .readthedocs.yml
 
-build:
-  image: latest
+version: 2
 
+build:
+  os: ubuntu-20.04
+  tools:
+    python: "3.9"
+    
 python:
-  version: 3.8
-  setup_py_install: true
\ No newline at end of file
+  install:
+    - method: pip
+      path: .
+    - requirements: requirements.txt
+    - method: pip
+      path: ./thermosteam
+    
+submodules:
+  include:
+    - thermosteam
+    
+sphinx:
+   configuration: docs/conf.py
+   
\ No newline at end of file
diff --git a/biosteam/_facility.py b/biosteam/_facility.py
index 7c8fdf2d7..dfc7cf755 100644
--- a/biosteam/_facility.py
+++ b/biosteam/_facility.py
@@ -16,6 +16,8 @@ def get_network_priority(facility):
 
 class Facility(Unit, isabstract=True,
                new_graphics=False):
+    """Abstract class for facilities that are run after simulation of all
+    unit operations within a system path."""
     autonumber = False # Default ID will not include number
     @staticmethod
     def ordered_facilities(facilities):
diff --git a/biosteam/_flowsheet.py b/biosteam/_flowsheet.py
index 4ec22eeac..5e3e0c9c5 100644
--- a/biosteam/_flowsheet.py
+++ b/biosteam/_flowsheet.py
@@ -8,6 +8,8 @@
 """
 As BioSTEAM objects are created, they are automatically registered. The `main_flowsheet` object allows the user to find any Unit, Stream or System instance.  When `main_flowsheet` is called, it simply looks up the item and returns it. 
 """
+from __future__ import annotations
+from typing import Optional, Iterable
 import biosteam as bst
 from thermosteam.utils import Registry
 from thermosteam import Stream
@@ -66,7 +68,7 @@ def __delattr__(self, key):
             super().__delattr__(key)
     
     def __repr__(self):
-        return 'Register:\n ' + '\n '.join([repr(i) for i in self])
+        return 'Flowsheets:\n ' + '\n '.join([str(i) for i in self])
     
     
 class Flowsheet:
@@ -77,25 +79,25 @@ class Flowsheet:
 	
     """
     
-    line = "Flowsheet"
+    line: str = "Flowsheet"
     
-    #: [Flowsheets] All flowsheets.
-    flowsheet = Flowsheets()
+    #: All flowsheets.
+    flowsheet: Flowsheets = Flowsheets()
     
     def __new__(cls, ID):        
         self = super().__new__(cls)
         
-        #: [Register] Contains all System objects as attributes.
-        self.system = Registry()
+        #: Contains all System objects as attributes.
+        self.system: Registry = Registry()
         
-        #: [Register] Contains all Unit objects as attributes.
-        self.unit = Registry()
+        #: Contains all Unit objects as attributes.
+        self.unit: Registry = Registry()
         
-        #: [Register] Contains all Stream objects as attributes.
-        self.stream = Registry()
+        #: Contains all Stream objects as attributes.
+        self.stream: Registry = Registry()
         
-        #: [str] ID of flowsheet.
-        self._ID = ID
+        #: ID of flowsheet.
+        self._ID: str = ID
         self.flowsheet.__dict__[ID] = self
         return self
     
@@ -189,69 +191,76 @@ def from_flowsheets(cls, ID, flowsheets):
             new.update(flowsheet)
         return new
     
-    def diagram(self, kind=None, file=None, format=None, display=True,
-                number=None, profile=None, label=None, title=None, **graph_attrs):
+    def diagram(self, kind: Optional[int|str]=None, file: Optional[str]=None, 
+                format: Optional[str]=None, display: Optional[bool]=True,
+                number: Optional[bool]=None, profile: Optional[bool]=None,
+                label: Optional[bool]=None, title: Optional[str]=None,
+                **graph_attrs):
         """
-        Display all units and attached streams.
-        
+        Display a `Graphviz <https://pypi.org/project/graphviz/>`__ diagram of
+        all unit operations.
+
         Parameters
         ----------
-        kind : int or string, optional
+        kind :
             * 0 or 'cluster': Display all units clustered by system.
             * 1 or 'thorough': Display every unit within the path.
             * 2 or 'surface': Display only elements listed in the path.
             * 3 or 'minimal': Display a single box representing all units.
-        file : str, display in console by default
-            File name to save diagram.
-        format : str
-            File format (e.g. "png", "svg"). Defaults to 'png'.
-        display : bool, optional
-            Whether to display diagram in console or to return the graphviz 
+        file : 
+            File name to save diagram. 
+        format:
+            File format (e.g. "png", "svg"). Defaults to 'png'
+        display : 
+            Whether to display diagram in console or to return the graphviz
             object.
-        number : bool, optional
-            Whether to number unit operations according to their 
+        number : 
+            Whether to number unit operations according to their
             order in the system path.
-        profile : bool, optional
+        profile : 
             Whether to clock the simulation time of unit operations.
-        label : bool, optional
+        label : 
             Whether to label the ID of streams with sources and sinks.
-            
+
         """
         if title is None: title = ''
         return self.create_system(None).diagram(kind or 'thorough', file, format,
                                                 display, number, profile, label,
                                                 title, **graph_attrs)
     
-    def create_system(self, ID="", ends=(), facility_recycle=None,
-                      operating_hours=None, lang_factor=None):
+    def create_system(self, ID: Optional[str]="", 
+                      ends: Optional[Iterable[Stream]]=None,
+                      facility_recycle: Optional[Stream]=None, 
+                      operating_hours: Optional[float]=None,
+                      lang_factor: Optional[float]=None):
         """
         Create a System object from all units and streams defined in the flowsheet.
         
         Parameters
         ----------
-        ID : str, optional
+        ID : 
             Name of system.
-        ends : Iterable[:class:`~thermosteam.Stream`], optional
+        ends : 
             End streams of the system which are not products. Specify this
-            argument if only a section of the complete system is wanted, or if 
+            argument if only a section of the complete system is wanted, or if
             recycle streams should be ignored.
-        facility_recycle : :class:`~thermosteam.Stream`, optional
+        facility_recycle : 
             Recycle stream between facilities and system path. This argument
             defaults to the outlet of a BlowdownMixer facility (if any).
-        operating_hours : float, optional
+        operating_hours : 
             Number of operating hours in a year. This parameter is used to
-            compute properties such as utility cost and material cost
-            on a per year basis. 
-        lang_factor : float, optional
-            Lang factor for getting fixed capital investment from 
-            total purchase cost. If no lang factor, installed equipment costs are 
+            compute annualized properties such as utility cost and material cost
+            on a per year basis.
+        lang_factor : 
+            Lang factor for getting fixed capital investment from
+            total purchase cost. If no lang factor, installed equipment costs are
             estimated using bare module factors.
         
         """
         return System.from_units(ID, self.unit, ends, facility_recycle,
                                  operating_hours, lang_factor)
     
-    def create_network(self, feeds=None, ends=()):
+    def _create_network(self, feeds=None, ends=()):
         """
         Create a Network object from all units and streams defined in the flowsheet.
         
@@ -274,15 +283,15 @@ def create_network(self, feeds=None, ends=()):
             network = Network([])
         return network
     
-    def __call__(self, ID, strict=False):
+    def __call__(self, ID: str|type[Unit], strict: Optional[bool]=False):
         """
 		Return requested biosteam item or a list of all matching items.
     
         Parameters
         ----------
-        ID : str or type
+        ID :
             ID of the requested item or Unit subclass.
-        strict : bool
+        strict : 
             Whether an exact match is required. 
             
         """
@@ -364,7 +373,7 @@ def __repr__(self):
         return f'<{type(self).__name__}: {self.ID}>'
     
     
-#: [main_flowsheet] Main flowsheet where objects are registered by ID.
+#: Main flowsheet where objects are registered by ID.
 main_flowsheet = object.__new__(MainFlowsheet)
 main_flowsheet.set_flowsheet(
     Flowsheet.from_registries(
diff --git a/biosteam/_heat_utility.py b/biosteam/_heat_utility.py
index 4c2c09bf3..3d97c4684 100644
--- a/biosteam/_heat_utility.py
+++ b/biosteam/_heat_utility.py
@@ -16,7 +16,7 @@
 from thermosteam import Thermo, Stream, ThermalCondition, settings
 from .exceptions import DimensionError
 from math import copysign
-from typing import Optional, TYPE_CHECKING, Iterable, Literal
+from typing import Optional, TYPE_CHECKING, Iterable, Literal, Sequence
 if TYPE_CHECKING: from biosteam import HXutility
 
 __all__ = ('HeatUtility', 'UtilityAgent')
@@ -38,22 +38,23 @@ class UtilityAgent(Stream):
     
     Parameters
     ----------
-    ID :
-        A unique identification. If ID is None, utility agent will not be registered.
-        If no ID is given, utility agent will be registered with a unique ID.
-    flow :
-        All flow rates corresponding to chemical `IDs`.
-    phase :
-        Either gas (g), liquid (l), or solid (s).
-    T :
-        Temperature [K]. Defaults to 298.15 K.
-    P :
-        Pressure [Pa]. Defaults to 101325 Pa.
-    units :
+    ID : 
+        A unique identification. If ID is None, stream will not be registered.
+        If no ID is given, stream will be registered with a unique ID.
+    flow : 
+        All flow rates corresponding to defined chemicals.
+    phase : 
+        'g' for gas, 'l' for liquid, and 's' for solid. Defaults to 'l'.
+    T : 
+        Temperature [K]. Defaults to 298.15.
+    P : 
+        Pressure [Pa]. Defaults to 101325.
+    units : 
         Flow rate units of measure (only mass, molar, and
-        volumetric flow rates are valid). Defaults to kmol/hr.
-    thermo :
-        Thermodynamic equilibrium package. Defaults to `biosteam.settings.get_thermo()`.
+        volumetric flow rates are valid). Defaults to 'kmol/hr'.
+    thermo : 
+        Thermo object to initialize input and output streams. Defaults to
+        `biosteam.settings.get_thermo()`.
     T_limit :
         Temperature limit of outlet utility streams [K]. If no limit is given,
         phase change is assumed. If utility agent heats up, `T_limit` is
@@ -65,19 +66,19 @@ class UtilityAgent(Stream):
         Price of regenerating the fluid for reuse [USD/kmol]. Defaults to 0.
     heat_transfer_efficiency :
         Fraction of heat transfered accounting for losses to the environment (must be between 0 to 1). Defaults to 1.
-    **chemical_flows :
+    **chemical_flows : float
         ID - flow pairs.
         
     """
     __slots__ = ('T_limit', '_heat_transfer_price',
                  '_regeneration_price', 'heat_transfer_efficiency')
     def __init__(self, 
-                 ID: str='', 
-                 flow: tuple[float, ...]=(),
-                 phase: Literal['s', 'l', 'g']='l',
-                 T: float=298.15,
-                 P: float=101325.,
-                 units: str='kmol/hr',
+                 ID: Optional[str]='', 
+                 flow: Sequence[float]=(),
+                 phase: Optional[str]='l',
+                 T: Optional[float]=298.15,
+                 P: Optional[float]=101325.,
+                 units: Optional[str]=None,
                  thermo: Optional[Thermo]=None, 
                  T_limit: Optional[float]=None,
                  heat_transfer_price: float=0.,
@@ -87,7 +88,7 @@ def __init__(self,
         self._thermal_condition = ThermalCondition(T, P)
         thermo = self._load_thermo(thermo)
         self._init_indexer(flow, phase, thermo.chemicals, chemical_flows)
-        if units != 'kmol/hr':
+        if units is not None:
             name, factor = self._get_flow_name_and_factor(units)
             flow = getattr(self, name)
             flow[:] = self.mol / factor
@@ -592,7 +593,8 @@ def set_utility_by_flow_rate(self, agent: Optional[UtilityAgent], F_mol: float):
         self.cost = agent._heat_transfer_price * abs(duty) + agent._regeneration_price * F_mol
         
     def __call__(self, unit_duty: float, T_in: float, T_out: Optional[float]=None, agent: Optional[UtilityAgent]=None):
-        """Calculate utility requirements given the essential parameters.
+        """
+        Calculate utility requirements given the essential parameters.
         
         Parameters
         ----------
diff --git a/biosteam/_preferences.py b/biosteam/_preferences.py
index 83124db42..46c790c84 100644
--- a/biosteam/_preferences.py
+++ b/biosteam/_preferences.py
@@ -216,8 +216,8 @@ def __exit__(self, type, exception, traceback):
         preferences.update(**self.__dict__)
         if exception: raise exception
 
-#: [BioSTEAMDisplayPreferences] All preferences for diagram and results display.
-preferences = BioSTEAMDisplayPreferences()
+#: All preferences for diagram and results display.
+preferences: BioSTEAMDisplayPreferences = BioSTEAMDisplayPreferences()
 if os.environ.get("FILTER_WARNINGS"):
     from warnings import filterwarnings; filterwarnings('ignore')
 if not os.environ.get("DISABLE_PREFERENCES") == "1":
diff --git a/biosteam/_system.py b/biosteam/_system.py
index 84bb99ebc..dbdff4852 100644
--- a/biosteam/_system.py
+++ b/biosteam/_system.py
@@ -10,13 +10,16 @@
 # for license details.
 """
 """
+from __future__ import annotations
+from typing import Optional, Callable, Iterable, Sequence, Collection, TYPE_CHECKING
 import flexsolve as flx
 from .digraph import (digraph_from_units_and_streams,
                       digraph_from_system,
                       minimal_digraph,
                       surface_digraph,
                       finalize_digraph)
-from thermosteam import Stream, MultiStream
+from thermosteam import Stream, MultiStream, Chemical
+from . import HeatUtility, PowerUtility
 from thermosteam.utils import registered
 from scipy.optimize import (
     anderson, diagbroyden, excitingmixing, linearmixing, 
@@ -28,11 +31,10 @@
 from ._unit import Unit, repr_ins_and_outs
 from .utils import (
     repr_items, ignore_docking_warnings, SystemScope,
-    StreamPorts, colors, list_available_names
+    piping, colors, list_available_names
 )
-from .report import save_report
 from .process_tools import utils
-from collections.abc import Iterable
+from collections import abc
 from warnings import warn
 from inspect import signature
 from thermosteam.utils import repr_kwargs
@@ -40,6 +42,10 @@
 import numpy as np
 import pandas as pd
 from scipy.integrate import solve_ivp
+from . import report
+import os
+import openpyxl
+if TYPE_CHECKING: from ._tea import TEA
 
 __all__ = ('System', 'AgileSystem', 'MockSystem',
            'AgileSystem', 'OperationModeResults',
@@ -50,6 +56,22 @@ def _reformat(name):
     if name.islower(): name= name.capitalize()
     return name
 
+# %% Convergence tools
+
+class MaterialData:
+    __slots__ = (
+        'material_flows',
+        'recycles',
+        'index',
+        'same_chemicals',
+    )
+    def __init__(self, material_flows, recycles, index, same_chemicals):
+        self.material_flows = material_flows
+        self.recycles = recycles
+        self.index = index
+        self.same_chemicals = same_chemicals
+        
+        
 # %% System creation tools
 
 def facilities_from_units(units):
@@ -168,22 +190,22 @@ def _load_flowsheet(self):
         self.flowsheet = flowsheet_module.main_flowsheet.get_flowsheet()
 
     @property
-    def ins(self):
-        """StreamPorts[:class:`~InletPort`] All inlets to the system."""
+    def ins(self) -> piping.StreamPorts[piping.InletPort]:
+        """All inlets to the system."""
         try:
             return self._ins
         except:
             inlets = bst.utils.feeds_from_units(self.units)
-            self._ins = ins = StreamPorts.from_inlets(inlets, sort=True)
+            self._ins = ins = piping.StreamPorts.from_inlets(inlets, sort=True)
             return ins
     @property
-    def outs(self):
-        """StreamPorts[:class:`~OutletPort`] All outlets to the system."""
+    def outs(self) -> piping.StreamPorts[piping.InletPort]:
+        """All outlets to the system."""
         try:
             return self._outs
         except:
             outlets = bst.utils.products_from_units(self.units)
-            self._outs = outs = StreamPorts.from_outlets(outlets, sort=True)
+            self._outs = outs = piping.StreamPorts.from_outlets(outlets, sort=True)
             return outs
 
     def load_inlet_ports(self, inlets):
@@ -193,7 +215,7 @@ def load_inlet_ports(self, inlets):
         for i in inlets:
             if i not in all_inlets:
                 raise ValueError(f'{i} is not an inlet')
-        self._ins = StreamPorts.from_inlets(inlets)
+        self._ins = piping.StreamPorts.from_inlets(inlets)
 
     def load_outlet_ports(self, outlets):
         """Load outlet ports to system."""
@@ -202,7 +224,7 @@ def load_outlet_ports(self, outlets):
         for i in outlets:
             if i not in all_outlets:
                 raise ValueError(f'{i} is not an outlet')
-        self._outs = StreamPorts.from_outlets(outlets)
+        self._outs = piping.StreamPorts.from_outlets(outlets)
 
     def __enter__(self):
         if self.units:
@@ -245,31 +267,32 @@ class System:
     """
     Create a System object that can iteratively run each element in a path
     of BioSTREAM objects until the recycle stream is converged. A path can
-    have function, Unit and/or System objects. When the path contains an
-    inner System object, it converges/solves it in each loop/iteration.
+    have :class:`~biosteam.Unit` and/or :class:`~biosteam.System` objects.
+    When the path contains an inner System object, it converges/solves it in
+    each loop/iteration.
 
     Parameters
     ----------
-    ID : str
-         A unique identification. If ID is None, instance will not be
+    ID :
+         Unique identification. If ID is None, instance will not be
          registered in flowsheet.
-    path : tuple[:class:`~biosteam.Unit`, function and/or :class:`~biosteam.System`], optional
-        A path that is run element by element until the recycle converges.
-    recycle=None : :class:`~thermosteam.Stream` or tuple[:class:`~thermosteam.Stream`], optional
-        A tear stream for the recycle loop.
-    facilities=() : tuple[:class:`~biosteam.Unit`, function, and/or :class:`~biosteam.System`], optional
+    path :
+        Path that is run element by element until the recycle converges.
+    recycle : 
+        Tear stream for the recycle loop.
+    facilities : 
         Offsite facilities that are simulated only after
         completing the path simulation.
-    facility_recycle : :class:`~thermosteam.Stream`, optional
+    facility_recycle : 
         Recycle stream between facilities and system path.
-    N_runs : int, optional
+    N_runs : 
         Number of iterations to run system. This parameter is applicable
         only to systems with no recycle loop.
-    operating_hours : float, optional
+    operating_hours :
         Number of operating hours in a year. This parameter is used to
         compute annualized properties such as utility cost and material cost
         on a per year basis.
-    lang_factor : float, optional
+    lang_factor : 
         Lang factor for getting fixed capital investment from
         total purchase cost. If no lang factor, installed equipment costs are
         estimated using bare module factors.
@@ -329,29 +352,29 @@ class System:
 
     ### Class attributes ###
 
-    #: [int] Default maximum number of iterations
-    default_maxiter = 200
+    #: Default maximum number of iterations
+    default_maxiter: int = 200
 
-    #: [float] Default molar tolerance for each component (kmol/hr)
-    default_molar_tolerance = 1.
+    #: Default molar tolerance for each component [kmol/hr]
+    default_molar_tolerance: float = 1.
 
-    #: [float] Default relative molar tolerance for each component
-    default_relative_molar_tolerance = 0.01
+    #: Default relative molar tolerance for each component
+    default_relative_molar_tolerance: float = 0.01
 
-    #: [float] Default temperature tolerance (K)
-    default_temperature_tolerance = 0.10
+    #: Default temperature tolerance [K]
+    default_temperature_tolerance: float = 0.10
 
-    #: [float] Default relative temperature tolerance
-    default_relative_temperature_tolerance = 0.001
+    #: Default relative temperature tolerance
+    default_relative_temperature_tolerance: float = 0.001
 
-    #: [str] Default convergence method.
-    default_method = 'Aitken'
+    #: Default convergence method.
+    default_method: str = 'Aitken'
 
-    #: [bool] Whether to raise a RuntimeError when system doesn't converge
-    strict_convergence = True
+    #: Whether to raise a RuntimeError when system doesn't converge
+    strict_convergence: bool = True
 
-    #: dict[str, (function, bool, kwargs)] Method definitions for convergence
-    available_methods = {}
+    #: Method definitions for convergence
+    available_methods: dict[str, tuple(Callable, bool, dict)] = {}
 
     @classmethod
     def register_method(cls, name, function, conditional=False, **kwargs):
@@ -359,68 +382,79 @@ def register_method(cls, name, function, conditional=False, **kwargs):
         cls.available_methods[name] = (function, conditional, kwargs)
 
     @classmethod
-    def from_feedstock(cls, ID, feedstock, feeds=None, facilities=(),
-                       ends=None, facility_recycle=None, operating_hours=None,
-                       lang_factor=None):
+    def from_feedstock(cls,
+            ID: Optional[str]='', 
+            feedstock: Stream=None, 
+            feeds: Optional[Iterable[Stream]]=None, 
+            facilities: Iterable[Facility]=(),
+            ends: Iterable[Stream]=None,
+            facility_recycle: Optional[Stream]=None,
+            operating_hours: Optional[float]=None,
+            lang_factor: Optional[float]=None,
+        ):
         """
         Create a System object from a feedstock.
 
         Parameters
         ----------
-        ID : str
+        ID : 
             Name of system.
-        feedstock : :class:`~thermosteam.Stream`
+        feedstock :
             Main feedstock of the process.
-        feeds : Iterable[:class:`~thermosteam.Stream`]
+        feeds : 
             Additional feeds to the process.
-        facilities : Iterable[Facility]
+        facilities : 
             Offsite facilities that are simulated only after
             completing the path simulation.
-        ends : Iterable[:class:`~thermosteam.Stream`]
+        ends : 
             Streams that not products, but are ultimately specified through
             process requirements and not by its unit source.
-        facility_recycle : [:class:`~thermosteam.Stream`], optional
+        facility_recycle : 
             Recycle stream between facilities and system path.
-        operating_hours : float, optional
+        operating_hours : 
             Number of operating hours in a year. This parameter is used to
             compute annualized properties such as utility cost and material cost
             on a per year basis.
-        lang_factor : float, optional
+        lang_factor : 
             Lang factor for getting fixed capital investment from
             total purchase cost. If no lang factor, installed equipment costs are
             estimated using bare module factors.
 
         """
+        if feedstock is None: raise ValueError('must pass feedstock stream')
         network = Network.from_feedstock(feedstock, feeds, ends)
-        return cls.from_network(ID, network, facilities,
+        return cls._from_network(ID, network, facilities,
                                 facility_recycle, operating_hours,
                                 lang_factor)
 
     @classmethod
-    def from_units(cls, ID="", units=None, ends=None,
-                   facility_recycle=None, operating_hours=None,
-                   lang_factor=None):
+    def from_units(cls, ID: Optional[str]="",
+                   units: Optional[Iterable[Unit]]=None, 
+                   ends: Optional[Iterable[Stream]]=None,
+                   facility_recycle: Optional[Stream]=None, 
+                   operating_hours: Optional[float]=None,
+                   lang_factor: Optional[float]=None):
         """
         Create a System object from all units given.
 
         Parameters
         ----------
-        ID : str, optional
+        ID : 
             Name of system.
-        units : Iterable[:class:`biosteam.Unit`], optional
+        units :
             Unit operations to be included.
-        ends : Iterable[:class:`~thermosteam.Stream`], optional
+        ends : 
             End streams of the system which are not products. Specify this
             argument if only a section of the complete system is wanted, or if
             recycle streams should be ignored.
-        facility_recycle : :class:`~thermosteam.Stream`, optional
+        facility_recycle : 
             Recycle stream between facilities and system path. This argument
             defaults to the outlet of a BlowdownMixer facility (if any).
-        operating_hours : float, optional
+        operating_hours : 
             Number of operating hours in a year. This parameter is used to
             compute annualized properties such as utility cost and material cost
             on a per year basis.
-        lang_factor : float, optional
+        lang_factor : 
             Lang factor for getting fixed capital investment from
             total purchase cost. If no lang factor, installed equipment costs are
             estimated using bare module factors.
@@ -428,29 +462,30 @@ def from_units(cls, ID="", units=None, ends=None,
         """
         facilities = facilities_from_units(units)
         network = Network.from_units(units, ends)
-        return cls.from_network(ID, network, facilities,
+        return cls._from_network(ID, network, facilities,
                                 facility_recycle, operating_hours,
                                 lang_factor)
 
     @classmethod
-    def from_segment(cls, ID="", start=None, end=None, operating_hours=None,
-                     lang_factor=None):
+    def from_segment(cls, ID: Optional[str]="", start: Optional[Unit]=None, 
+                     end: Optional[Unit]=None, operating_hours: Optional[float]=None,
+                     lang_factor: Optional[float]=None):
         """
         Create a System object from all units in between start and end.
 
         Parameters
         ----------
-        ID : str, optional
+        ID : 
             Name of system.
-        start : Unit, optional
+        start :
             Only downstream units from start are included in the system.
-        end : Unit, optional
+        end : 
             Only upstream units from end are included in the system.
-        operating_hours : float, optional
+        operating_hours : 
             Number of operating hours in a year. This parameter is used to
             compute annualized properties such as utility cost and material cost
             on a per year basis.
-        lang_factor : float, optional
+        lang_factor : 
             Lang factor for getting fixed capital investment from
             total purchase cost. If no lang factor, installed equipment costs are
             estimated using bare module factors.
@@ -469,7 +504,7 @@ def from_segment(cls, ID="", start=None, end=None, operating_hours=None,
                                      lang_factor=lang_factor)
          
     @classmethod
-    def from_network(cls, ID, network, facilities=(), facility_recycle=None,
+    def _from_network(cls, ID, network, facilities=(), facility_recycle=None,
                      operating_hours=None, lang_factor=None):
         """
         Create a System object from a network.
@@ -499,36 +534,46 @@ def from_network(cls, ID, network, facilities=(), facility_recycle=None,
         if facility_recycle is None: facility_recycle = find_blowdown_recycle(facilities)
         isa = isinstance
         ID_subsys = None if ID is None else ''
-        path = [(cls.from_network(ID_subsys, i) if isa(i, Network) else i)
+        path = [(cls._from_network(ID_subsys, i) if isa(i, Network) else i)
                 for i in network.path]
-        self = cls.__new__(cls)
-        self.recycle = network.recycle
-        self._set_path(path)
-        self._specification = None
-        self._load_flowsheet()
-        self._reset_errors()
-        self._set_facilities(facilities)
-        self._set_facility_recycle(facility_recycle)
-        self._register(ID)
-        self._load_defaults()
-        self._save_configuration()
-        self._load_stream_links()
-        self._configuration_updated = False
-        self.operating_hours = operating_hours
-        self.lang_factor = lang_factor
-        self._state = None
-        self._state_idx = None
-        self._state_header = None
-        self._DAE = None
-        self.dynsim_kwargs = {}
-        self.tracked_recycles = {}
-        return self
-
-    def __init__(self, ID, path=(), recycle=None, facilities=(),
-                 facility_recycle=None, N_runs=None, operating_hours=None,
-                 lang_factor=None):
-        self.recycle = recycle
+        return cls(ID, path, network.recycle, facilities, facility_recycle, None,
+                   operating_hours, lang_factor)
+
+    def __init__(self, 
+            ID: Optional[str]= '', 
+            path: Optional[Iterable[Unit|System]]=(), 
+            recycle: Optional[Stream]=None, 
+            facilities: Iterable[Facility]=(),
+            facility_recycle: Optional[Stream]=None, 
+            N_runs: Optional[int]=None,
+            operating_hours: Optional[float]=None,
+            lang_factor: Optional[float]=None
+        ):
         self.N_runs = N_runs
+        self.recycle = recycle
+        self.method = self.default_method   
+        
+        #: Maximum number of iterations.
+        self.maxiter: int = self.default_maxiter
+
+        #: Molar tolerance [kmol/hr].
+        self.molar_tolerance: float = self.default_molar_tolerance
+
+        #: Relative molar tolerance.
+        self.relative_molar_tolerance: float = self.default_relative_molar_tolerance
+
+        #: Temperature tolerance [K].
+        self.temperature_tolerance: float = self.default_temperature_tolerance
+
+        #: Relative temperature tolerance.
+        self.relative_temperature_tolerance: float = self.default_relative_temperature_tolerance
+
+        #: Number of operating hours per year
+        self.operating_hours: float|None = operating_hours
+        
+        #: Lang factor for computing fixed capital cost from purchase costs
+        self.lang_factor: float|None = lang_factor
+
         self._set_path(path)
         self._specification = None
         self._load_flowsheet()
@@ -536,12 +581,9 @@ def __init__(self, ID, path=(), recycle=None, facilities=(),
         self._set_facilities(facilities)
         self._set_facility_recycle(facility_recycle)
         self._register(ID)
-        self._load_defaults()
         self._save_configuration()
         self._load_stream_links()
         self._configuration_updated = False
-        self.operating_hours = operating_hours
-        self.lang_factor = lang_factor
         self._state = None
         self._state_idx = None
         self._state_header = None
@@ -549,7 +591,7 @@ def __init__(self, ID, path=(), recycle=None, facilities=(),
         self.dynsim_kwargs = {}
         self.tracked_recycles = {}
 
-    def track_recycle(self, recycle, collector=None):
+    def track_recycle(self, recycle: Stream, collector: list[Stream]=None):
         if not isinstance(recycle, Stream):
             for i in recycle: self.track_recycle(recycle, collector)
         if collector is None: collector = []
@@ -559,7 +601,10 @@ def track_recycle(self, recycle, collector=None):
         if system is self: return
         system.track_recycle(recycle, collector)
 
-    def update_configuration(self, units=None, facility_recycle=None):
+    def update_configuration(self,
+            units: Optional[Sequence[str]]=None,
+            facility_recycle: Optional[Stream]=None
+        ):
         if units is None: units = self.units
         for i in ('_subsystems', '_units', '_unit_path', '_cost_units', '_streams', '_feeds', '_products'):
             if hasattr(self, i): delattr(self, i)
@@ -568,7 +613,7 @@ def update_configuration(self, units=None, facility_recycle=None):
         facilities = Facility.ordered_facilities([i for i in units if isa(i, Facility)])
         ID_subsys = None if '.' in self.ID else ''
         network = Network.from_units(units)
-        path = [(type(self).from_network(ID_subsys, i) if isa(i, Network) else i)
+        path = [(type(self)._from_network(ID_subsys, i) if isa(i, Network) else i)
                 for i in network.path]
         self.recycle = network.recycle
         self._reset_errors()
@@ -701,7 +746,7 @@ def _delete_path_cache(self):
             if hasattr(self, i): delattr(self, i)
         for i in self.subsystems: i._delete_path_cache()
 
-    def reduce_chemicals(self, required_chemicals=()):
+    def reduce_chemicals(self, required_chemicals: Collection[Chemical]=()):
         self._delete_path_cache()
         unit_thermo = {}
         mixer_thermo = {}
@@ -722,7 +767,7 @@ def copy(self, ID=None):
         new.copy_like(self)
         return new
 
-    def copy_like(self, other):
+    def copy_like(self, other: System):
         """Copy path, facilities and recycle from other system."""
         self._path = other._path
         self._facilities = other._facilities
@@ -732,29 +777,30 @@ def copy_like(self, other):
         self._recycle = other._recycle
         self._connections = other._connections
 
-    def set_tolerance(self, mol=None, rmol=None, T=None, rT=None, 
-                      subsystems=False, maxiter=None, subfactor=None,
-                      method=None):
+    def set_tolerance(self, mol: Optional[float]=None, rmol: Optional[float]=None,
+                      T: Optional[float]=None, rT: Optional[float]=None, 
+                      subsystems: bool=False, maxiter: Optional[int]=None, 
+                      subfactor: Optional[float]=None, method: Optional[str]=None):
         """
         Set the convergence tolerance and convergence method of the system.
 
         Parameters
         ----------
-        mol : float, optional
+        mol :
             Molar tolerance.
-        rmol : float, optional
+        rmol :
             Relative molar tolerance.
-        T : float, optional
+        T :
             Temperature tolerance.
-        rT : float, optional
+        rT :
             Relative temperature tolerance.
-        subsystems : bool, optional
+        subsystems :
             Whether to set tolerance and method of subsystems as well.
-        maxiter : int, optional
+        maxiter :
             Maximum number if iterations.
-        subfactor : float, optional
+        subfactor :
             Factor to rescale tolerance in subsystems.
-        method : str, optional
+        method :
             Convergence method.
         
         """
@@ -780,37 +826,18 @@ def set_tolerance(self, mol=None, rmol=None, T=None, rT=None,
     def _load_stream_links(self):
         for u in self.units: u._load_stream_links()
 
-    def _load_defaults(self):
-        #: [int] Maximum number of iterations.
-        self.maxiter = self.default_maxiter
-
-        #: [float] Molar tolerance (kmol/hr)
-        self.molar_tolerance = self.default_molar_tolerance
-
-        #: [float] Relative molar tolerance
-        self.relative_molar_tolerance = self.default_relative_molar_tolerance
-
-        #: [float] Temperature tolerance (K)
-        self.temperature_tolerance = self.default_temperature_tolerance
-
-        #: [float] Relative temperature tolerance
-        self.relative_temperature_tolerance = self.default_relative_temperature_tolerance
-
-        #: [str] Converge method
-        self.method = self.default_method
-
     @property
-    def TEA(self):
+    def TEA(self) -> TEA:
         """TEA object linked to the system."""
         return getattr(self, '_TEA', None)
 
     @property
     def LCA(self):
-        """TEA object linked to the system."""
+        """QSDsan.LCA object linked to the system."""
         return getattr(self, '_LCA', None)
 
     @property
-    def specification(self):
+    def specification(self) -> Callable:
         """Process specification."""
         return self._specification
     @specification.setter
@@ -826,15 +853,13 @@ def specification(self, specification):
         else:
             self._specification = None
 
-    save_report = save_report
-
     def _extend_recycles(self, recycles):
         isa = isinstance
         recycle = self._recycle
         if recycle:
             if isa(recycle, Stream):
                 recycles.append(recycle)
-            elif isa(recycle, Iterable):
+            elif isa(recycle, abc.Iterable):
                 recycles.extend(recycle)
             else:
                 raise_recycle_type_error(recycle)
@@ -853,7 +878,7 @@ def _extend_flattend_path_and_recycles(self, path, recycles, stacklevel):
         if recycle:
             if isa(recycle, Stream):
                 recycles.append(recycle)
-            elif isa(recycle, Iterable):
+            elif isa(recycle, abc.Iterable):
                 recycles.extend(recycle)
             else:
                 raise_recycle_type_error(recycle)
@@ -872,14 +897,14 @@ def _extend_flattend_path_and_recycles(self, path, recycles, stacklevel):
             else:
                 path.append(i)
 
-    def prioritize_unit(self, unit):
+    def prioritize_unit(self, unit: Unit):
         """
         Prioritize unit operation to run first within it's recycle system,
         if there is one.
 
         Parameters
         ----------
-        unit : Unit
+        unit : 
             Unit operation to prioritize.
 
         Raises
@@ -931,7 +956,7 @@ def prioritize_unit(self, unit):
                 return
         raise RuntimeError('problem in system algorithm')
 
-    def find_system(self, unit):
+    def find_system(self, unit: Unit):
         """
         Return system containing given unit within it's path.
         """
@@ -943,17 +968,20 @@ def find_system(self, unit):
                 return self
         raise ValueError(f"unit {repr(unit)} not within system {repr(self)}")
 
-    def split(self, stream, ID_upstream=None, ID_downstream=None):
+    def split(self, 
+              stream: Stream,
+              ID_upstream: Optional[str]=None,
+              ID_downstream: Optional[str]=None):
         """
         Split system in two; upstream and downstream.
 
         Parameters
         ----------
-        stream : Iterable[:class:~thermosteam.Stream], optional
+        stream : 
             Stream where unit group will be split.
-        ID_upstream : str, optional
+        ID_upstream : 
             ID of upstream system.
-        ID_downstream : str, optional
+        ID_downstream : 
             ID of downstream system.
 
         Examples
@@ -997,7 +1025,7 @@ def flatten(self):
         self.molar_tolerance *= N_recycles
         self.temperature_tolerance *= N_recycles
 
-    def to_unit_group(self, name=None):
+    def to_unit_group(self, name: Optional[str]=None):
         """Return a UnitGroup object of all units within the system."""
         return bst.UnitGroup(name, self.units)
 
@@ -1045,8 +1073,8 @@ def _set_facility_recycle(self, recycle):
     __rpow__ = __rsub__
 
     @property
-    def subsystems(self):
-        """list[System] All subsystems in the system."""
+    def subsystems(self) -> list[System]:
+        """All subsystems in the system."""
         try:
             return self._subsystems
         except:
@@ -1054,8 +1082,8 @@ def subsystems(self):
             return self._subsystems
 
     @property
-    def units(self):
-        """[list] All unit operations as ordered in the path without repetitions."""
+    def units(self) -> list[Unit]:
+        """All unit operations as ordered in the path without repetitions."""
         try:
             return self._units
         except:
@@ -1074,8 +1102,8 @@ def units(self):
             return units
 
     @property
-    def unit_path(self):
-        """[list] Unit operations as ordered in the path (some units may be repeated)."""
+    def unit_path(self) -> list[Unit]:
+        """Unit perations as ordered in the path (some units may be repeated)."""
         try:
             return self._unit_path
         except:
@@ -1089,8 +1117,8 @@ def unit_path(self):
             return units
 
     @property
-    def cost_units(self):
-        """[set] All unit operations with costs."""
+    def cost_units(self) -> set[Unit]:
+        """All unit operations with costs."""
         try:
             return self._cost_units
         except:
@@ -1104,8 +1132,8 @@ def cost_units(self):
             return units
         
     @property
-    def streams(self):
-        """set[:class:`~thermosteam.Stream`] All streams within the system."""
+    def streams(self) -> list[Stream]:
+        """All streams within the system."""
         try:
             return self._streams
         except:
@@ -1113,16 +1141,16 @@ def streams(self):
             bst.utils.filter_out_missing_streams(streams)
             return streams
     @property
-    def feeds(self):
-        """set[:class:`~thermosteam.Stream`] All feeds to the system."""
+    def feeds(self) -> list[Stream]:
+        """All feeds to the system."""
         try:
             return self._feeds
         except:
             self._feeds = feeds = bst.utils.feeds(self.streams)
             return feeds
     @property
-    def products(self):
-        """set[:class:`~thermosteam.Stream`] All products of the system."""
+    def products(self) -> list[Stream]:
+        """All products of the system."""
         try:
             return self._products
         except:
@@ -1130,14 +1158,13 @@ def products(self):
             return products
 
     @property
-    def facilities(self):
-        """tuple[Facility] All system facilities."""
+    def facilities(self)  -> tuple[Facility, ...]:
+        """All system facilities."""
         return self._facilities
 
     @property
-    def recycle(self):
+    def recycle(self) -> Stream|None:
         """
-        :class:`~thermosteam.Stream` or Iterable[:class:`~thermosteam.Stream`]
         A tear stream for the recycle loop.
         """
         return self._recycle
@@ -1149,7 +1176,7 @@ def recycle(self, recycle):
             self._recycle = recycle
         elif isa(recycle, Stream):
             self._recycle = recycle
-        elif isa(recycle, Iterable):
+        elif isa(recycle, abc.Iterable):
             recycle = sorted(set(recycle), key=lambda x: x._ID)
             for i in recycle:
                 if not isa(i, Stream):
@@ -1160,7 +1187,7 @@ def recycle(self, recycle):
             raise_recycle_type_error(recycle)
 
     @property
-    def N_runs(self):
+    def N_runs(self) -> int|None:
         """Number of times to run the path."""
         return self._N_runs
     @N_runs.setter
@@ -1169,16 +1196,12 @@ def N_runs(self, N_runs):
         self._N_runs = N_runs
 
     @property
-    def path(self):
-        """
-        tuple[Unit, function and/or System] A path that is run element by
-        element until the recycle(s) converges (if any).
-
-        """
+    def path(self) -> list[Unit|System]:
+        """A path that is run element by element until the recycle(s) converges (if any)."""
         return self._path
 
     @property
-    def method(self):
+    def method(self) -> str:
         """Iterative convergence method ('wegstein', 'aitken', or 'fixedpoint')."""
         return self._method
     @method.setter
@@ -1195,7 +1218,7 @@ def method(self, method):
     converge_method = method # For backwards compatibility
 
     @property
-    def isdynamic(self):
+    def isdynamic(self) -> bool:
         """Whether the system contains any dynamic Unit."""
         try:
             return self._isdynamic
@@ -1271,32 +1294,35 @@ def _thorough_digraph(self, graph_attrs):
     def _cluster_digraph(self, graph_attrs):
         return digraph_from_system(self, **graph_attrs)
 
-    def diagram(self, kind=None, file=None, format=None, display=True,
-                number=None, profile=None, label=None, title=None, **graph_attrs):
+    def diagram(self, kind: Optional[int|str]=None, file: Optional[str]=None, 
+                format: Optional[str]=None, display: Optional[bool]=True,
+                number: Optional[bool]=None, profile: Optional[bool]=None,
+                label: Optional[bool]=None, title: Optional[str]=None,
+                **graph_attrs):
         """
         Display a `Graphviz <https://pypi.org/project/graphviz/>`__ diagram of
         the system.
 
         Parameters
         ----------
-        kind : int or string, optional
+        kind :
             * 0 or 'cluster': Display all units clustered by system.
             * 1 or 'thorough': Display every unit within the path.
             * 2 or 'surface': Display only elements listed in the path.
             * 3 or 'minimal': Display a single box representing all units.
-        file=None : str, display in console by default
-            File name to save diagram.
-        format='png' : str
-            File format (e.g. "png", "svg").
-        display : bool, optional
+        file : 
+            File name to save diagram. 
+        format:
+            File format (e.g. "png", "svg"). Defaults to 'png'
+        display : 
             Whether to display diagram in console or to return the graphviz
             object.
-        number : bool, optional
+        number : 
             Whether to number unit operations according to their
             order in the system path.
-        profile : bool, optional
+        profile : 
             Whether to clock the simulation time of unit operations.
-        label : bool, optional
+        label : 
             Whether to label the ID of streams with sources and sinks.
 
         """
@@ -1452,7 +1478,7 @@ def _get_recycle_temperatures(self):
         recycle = self._recycle
         if isinstance(recycle, Stream):
             T = self._recycle.T
-        elif isinstance(recycle, Iterable):
+        elif isinstance(recycle, abc.Iterable):
             T = [i.T for i in recycle]
         else:
             raise RuntimeError('no recycle available')
@@ -1490,7 +1516,7 @@ def _solve(self):
 
     def get_material_data(self):
         """
-        Return a dictionary defining material flows of recycle streams.
+        Return a MaterialData object defining material flows of recycle streams.
         
         """
         recycles = self.get_all_recycles()
@@ -1511,57 +1537,45 @@ def get_material_data(self):
             for i, s in enumerate(recycles):
                 for ID, value in zip(s.chemicals.IDs, s.mol):
                     material_flows[i, index[ID]] = value
-        return dict(
+        return MaterialData(
             material_flows=material_flows,
             recycles=recycles,
             index=index,
             same_chemicals=same_chemicals,
         )
 
-    def converge(self, material_flows=None, recycles=None, index=None, same_chemicals=None):
+    def converge(self, material_data: MaterialData=None):
         """
-        Converge mass and energy balances.
+        Converge mass and energy balances. If material data was given, 
+        return converged material flows at steady state. Shape will be M by N,
+        where M is the number of recycle streams and N is the number of chemicals.
         
         Parameters
         ----------
-        material_flows : array, optional
-            Guess material flows of recycle streams. Shape must be M by N,
-            where M is the number of recycle streams and N is the number of chemicals.
-        
-        Other Parameters
-        ----------------
-        recycles : Iterable[Stream], optional
-            Recycle streams.
-        index : Iterable[str], optional
-            Index of chemical IDs for material flows.
-        same_chemicals : bool, optional
-            Whether all recycles share the same chemicals.
-            
-        Returns
-        -------
-        material_flows : array
-            If guess material flows were given, return converged material flows
-            at steady state.
+        material_data : 
+            Material data to set recycle streams.
             
+        See Also
+        --------
+        :meth:`System~.get_material_data`
+        
         Warning
         -------
         No design, costing, nor facility algorithms are run.
         To run full simulation algorithm, see :func:`~biosteam.System.simulate`.
         
         """
-        if material_flows is not None: 
-            if recycles is None: recycles = self.get_all_recycles()
-            if same_chemicals is None:
-                all_IDs = [s.chemicals.IDs for s in recycles]
-                same_chemicals = len(set(all_IDs)) == 1
+        if material_data is not None: 
+            material_flows = material_data.material_flows
+            recycles = material_data.recycles
+            index = material_data.index
+            same_chemicals = material_data.same_chemicals
             if same_chemicals:
                 for i, s in enumerate(recycles):
                     s.mol[:] = material_flows[i]
             else:
-                if index is None:
-                    IDs = sorted(set(sum([s.chemicals.IDs for s in recycles], ())))
-                    index = {j: i for i, j in enumerate(IDs)}
-                for i, s in enumerate(recycles):
+                
+                for i, s in enumerate(material_data.recycles):
                     mol = s.mol
                     for j, ID in enumerate(s.chemicals.IDs):
                         mol[j] = material_flows[i, index[ID]]
@@ -1571,7 +1585,7 @@ def converge(self, material_flows=None, recycles=None, index=None, same_chemical
             self._solve()
         else:
             self._run()
-        if material_flows is not None:
+        if material_data is not None:
             material_flows = material_flows.copy()
             if same_chemicals:
                 for i, s in enumerate(recycles): material_flows[i] = s.mol
@@ -1646,14 +1660,14 @@ def empty_recycles(self):
         if recycle:
             if isinstance(recycle, Stream):
                 recycle.empty()
-            elif isinstance(recycle, Iterable):
+            elif isinstance(recycle, abc.Iterable):
                 for i in recycle: i.empty()
             else:
                 raise_recycle_type_error(recycle)
         for system in self.subsystems:
             system.empty_recycles()
 
-    def rescale(self, feedstock, ratio):
+    def rescale(self, feedstock: Stream, ratio: float):
         """Rescale feedstock flow rate and update recycle stream flow rate guesses."""
         feedstock.rescale(ratio)
         for i in self.get_all_recycles(): i.rescale(ratio)
@@ -1688,9 +1702,9 @@ def set_dynamic_tracker(self, *subjects, **kwargs):
                  f'set up a dynamic tracker.')
         
     @property
-    def scope(self):
+    def scope(self) -> SystemScope:
         """
-        [:class:`SystemScope`] A tracker of dynamic data of the system, set up
+        A tracker of dynamic data of the system, set up
         with :class:`System`.`set_dynamic_tracker()`
         """
         if not hasattr(self, '_scope'): self._scope = SystemScope(self)
@@ -1831,10 +1845,10 @@ def dynamic_run(self, **dynsim_kwargs):
         **dynsim_kwargs : 
             Dynamic simulation keyword arguments, could include:
 
-                t_span : tuple(float, float)
+                t_span : tuple[float, float]
                     Interval of integration (t0, tf).
                     The solver starts with t=t0 and integrates until it reaches t=tf.
-                state_reset_hook: str or callable
+                state_reset_hook: str|Callable
                     Hook function to reset the cache state between simulations
                     for dynamic systems).
                     Can be "reset_cache" or "clear_state" to call `System.reset_cache`
@@ -1895,22 +1909,22 @@ def dynamic_run(self, **dynsim_kwargs):
 
     # User definitions
     
-    def define_process_impact(self, key, name, basis, inventory, CF):
+    def define_process_impact(self, key: str, name: str, basis: str, inventory: Callable, CF: float):
         """
         Define a process impact.
 
         Parameters
         ----------
-        key : str
+        key :
             Impact indicator key.
-        name : str
+        name :
             Name of process impact.
-        basis : str
+        basis :
             Functional unit for the characterization factor.
-        inventory : callable
+        inventory : 
             Should return the annualized (not hourly) inventory flow rate 
             given no parameters. Units should be in basis / yr
-        CF : float
+        CF : 
             Characterization factor in impact / basis.
 
         """
@@ -1933,14 +1947,14 @@ def define_process_impact(self, key, name, basis, inventory, CF):
     # Convenience methods
 
     @property
-    def heat_utilities(self):
-        """tuple[HeatUtility] the sum of all heat utilities in the system by agent."""
-        return bst.HeatUtility.sum_by_agent(utils.get_heat_utilities(self.cost_units))
+    def heat_utilities(self) -> tuple[HeatUtility, ...]:
+        """The sum of all heat utilities in the system by agent."""
+        return HeatUtility.sum_by_agent(utils.get_heat_utilities(self.cost_units))
 
     @property
-    def power_utility(self):
-        """[PowerUtility] Sum of all power utilities in the system."""
-        return bst.PowerUtility.sum(utils.get_power_utilities(self.cost_units))
+    def power_utility(self) -> PowerUtility:
+        """Sum of all power utilities in the system."""
+        return PowerUtility.sum(utils.get_power_utilities(self.cost_units))
 
     def get_inlet_utility_flows(self):
         """
@@ -1976,15 +1990,15 @@ def get_outlet_utility_flows(self):
                         dct[name] = flow
         return dct
 
-    def get_inlet_flow(self, units, key=None):
+    def get_inlet_flow(self, units: str, key: Optional[Sequence[str]|str]=None):
         """
         Return total flow across all inlets per year.
 
         Parameters
         ----------
-        units : str
+        units : 
             Material units of measure (e.g., 'kg', 'gal', 'kmol').
-        key : tuple[str] or str, optional
+        key : 
             Chemical identifiers. If none given, the sum of all chemicals returned
 
         Examples
@@ -2007,15 +2021,15 @@ def get_inlet_flow(self, units, key=None):
         else:
             return self.operating_hours * sum([i.get_total_flow(units) for i in bst.utils.feeds_from_units(self.units)])
 
-    def get_outlet_flow(self, units, key=None):
+    def get_outlet_flow(self, units: str, key: Optional[Sequence[str]|str]=None):
         """
         Return total flow across all outlets per year.
 
         Parameters
         ----------
-        units : str
+        units : 
             Material units of measure (e.g., 'kg', 'gal', 'kmol').
-        key : tuple[str] or str, optional
+        key : 
             Chemical identifiers. If none given, the sum of all chemicals returned
 
         Examples
@@ -2039,19 +2053,19 @@ def get_outlet_flow(self, units, key=None):
         else:
             return self.operating_hours * sum([i.get_total_flow(units) for i in bst.utils.products_from_units(self.units)])
     
-    def get_mass_flow(self, stream):
+    def get_mass_flow(self, stream: Stream):
         """Return the mass flow rate of a stream [kg/yr]."""
         return stream.F_mass * self.operating_hours
     
-    def get_market_value(self, stream):
+    def get_market_value(self, stream: Stream):
         """Return the market value of a stream [USD/yr]."""
         return stream.cost * self.operating_hours
 
-    def has_market_value(self, stream):
+    def has_market_value(self, stream: Stream):
         """Return whether stream has a market value."""
         return bool(stream.price) and not stream.isempty()
         
-    def get_property(self, stream, name, units=None):
+    def get_property(self, stream: Stream, name: str, units=None):
         """Return the annualized property of a stream."""
         return stream.get_property(name, units) * self.operating_hours
 
@@ -2067,7 +2081,10 @@ def _price2cost(self, stream):
         else:
             raise ValueError("stream must be either a feed or a product")
 
-    def get_net_heat_utility_impact(self, agent, key, heat_utilities=None):
+    def get_net_heat_utility_impact(self, 
+            agent: bst.UtilityAgent, key: str,
+            heat_utilities: Optional[tuple[bst.HeatUtility]]=None
+        ):
         if isinstance(agent, str): 
             ID = agent
             agent = bst.HeatUtility.get_agent(ID)
@@ -2260,24 +2277,24 @@ def get_displacement_allocation_factors(self, main_product, key):
         return {i: j / total for i, j in allocation_factors.items()}
     
     @property
-    def sales(self):
-        """Annual sales revenue."""
+    def sales(self) -> float:
+        """Annual sales revenue [USD/yr]."""
         return sum([s.cost for s in self.products if s.price]) * self.operating_hours
     @property
-    def material_cost(self):
-        """Annual material cost."""
+    def material_cost(self) -> float:
+        """Annual material cost [USD/yr]."""
         return sum([s.cost for s in self.feeds if s.price]) * self.operating_hours
     @property
-    def utility_cost(self):
-        """Total utility cost in USD/yr."""
+    def utility_cost(self) -> float:
+        """Total utility cost [USD/yr]."""
         return sum([u.utility_cost for u in self.cost_units]) * self.operating_hours
     @property
-    def purchase_cost(self):
-        """Total purchase cost in USD."""
+    def purchase_cost(self) -> float:
+        """Total purchase cost [USD]."""
         return sum([u.purchase_cost for u in self.cost_units])
     @property
-    def installed_equipment_cost(self):
-        """Total installed cost (USD)."""
+    def installed_equipment_cost(self) -> float:
+        """Total installed cost [USD]."""
         lang_factor = self.lang_factor
         if lang_factor:
             return sum([u.purchase_cost for u in self.cost_units]) * lang_factor
@@ -2285,42 +2302,135 @@ def installed_equipment_cost(self):
             return sum([u.installed_cost for u in self.cost_units])
 
     def get_electricity_consumption(self):
-        """Return the total electricity consumption in kWhr / yr."""
+        """Return the total electricity consumption [kWhr/yr]."""
         return self.operating_hours * self.power_utility.consumption
 
     def get_electricity_production(self):
-        """Return the total electricity production in kWhr / yr."""
+        """Return the total electricity production [kWhr/yr]."""
         return self.operating_hours * self.power_utility.production
     
     def get_utility_duty(self, agent):
-        """Return the total utility duty for given agent in kJ/yr."""
+        """Return the total utility duty for given agent [kJ/yr]."""
         if not isinstance(agent, str): agent = agent.ID
         return self.operating_hours * sum([i.duty for i in self.heat_utilities if i.agent.ID == agent]) 
     
     def get_utility_flow(self, agent):
-        """Return the total utility flow for given agent in kmol/yr."""
+        """Return the total utility flow for given agent [kmol/yr]."""
         if not isinstance(agent, str): agent = agent.ID
         return self.operating_hours * sum([i.flow for i in self.heat_utilities if i.agent.ID == agent]) 
     
     def get_cooling_duty(self):
-        """Return the total cooling duty in kJ/yr."""
+        """Return the total cooling duty [kJ/yr]."""
         return - self.operating_hours * sum([i.duty for i in self.heat_utilities if i.flow * i.duty < 0])
     
     def get_heating_duty(self):
-        """Return the total heating duty in kJ/yr."""
+        """Return the total heating duty [kJ/yr]."""
         return self.operating_hours * sum([i.duty for i in self.heat_utilities if i.flow * i.duty > 0])
     
     # Other
-    def to_network(self):
+    def _to_network(self):
         """Return network that defines the system path."""
         isa = isinstance
-        path = [(i.to_network() if isa(i, System) else i) for i in self._path]
+        path = [(i._to_network() if isa(i, System) else i) for i in self._path]
         network = Network.__new__(Network)
         network.path = path
         network.recycle = self._recycle
         network.units = set(self.unit_path)
         return network
 
+    # Report summary
+    def save_report(self, file: Optional[str]='report.xlsx', dpi: Optional[str]='300', **stream_properties): 
+        """
+        Save a system report as an xlsx file.
+        
+        Parameters
+        ----------
+        file : 
+            File name to save report
+        dpi : 
+            Resolution of the flowsheet. Defaults to '300'
+        **stream_properties : str
+            Additional stream properties and units as key-value pairs (e.g. T='degC', flow='gpm', H='kW', etc..)
+            
+        """
+        writer = pd.ExcelWriter(file)
+        units = sorted(self.units, key=lambda x: x.line)
+        cost_units = [i for i in units if i._design or i._cost]
+        try:
+            with bst.preferences.temporary() as p:
+                p.reset()
+                p.light_mode()
+                self.diagram('thorough', file='flowsheet', dpi=str(dpi), format='png')
+        except:
+            diagram_completed = False
+            warn(RuntimeWarning('failed to generate diagram through graphviz'), stacklevel=2)
+        else:
+            import PIL.Image
+            try:
+                # Assume openpyxl is used
+                worksheet = writer.book.create_sheet('Flowsheet')
+                flowsheet = openpyxl.drawing.image.Image('flowsheet.png')
+                worksheet.add_image(flowsheet, anchor='A1')
+            except PIL.Image.DecompressionBombError:
+                PIL.Image.MAX_IMAGE_PIXELS = int(1e9)
+                flowsheet = openpyxl.drawing.image.Image('flowsheet.png')
+                worksheet.add_image(flowsheet, anchor='A1')
+            except:
+                # Assume xlsx writer is used
+                try:
+                    worksheet = writer.book.add_worksheet('Flowsheet')
+                except:
+                    warn("problem in saving flowsheet; please submit issue to BioSTEAM with"
+                         "your current version of openpyxl and xlsx writer", RuntimeWarning)
+                worksheet.insert_image('A1', 'flowsheet.png')
+            diagram_completed = True
+        
+        tea = self.TEA
+        if tea:
+            tea = self.TEA
+            cost = report.cost_table(tea)
+            cost.to_excel(writer, 'Itemized costs')
+            tea.get_cashflow_table().to_excel(writer, 'Cash flow')
+        else:
+            warn(f'Cannot find TEA object in {repr(self)}. Ignoring TEA sheets.',
+                 RuntimeWarning, stacklevel=2)
+        
+        # Stream tables
+        # Organize streams by chemicals first
+        streams_by_chemicals = {}
+        for i in self.streams:
+            if not i: continue
+            chemicals = i.chemicals
+            if chemicals in streams_by_chemicals:
+                streams_by_chemicals[chemicals].append(i)
+            else:
+                streams_by_chemicals[chemicals] = [i]
+        stream_tables = []
+        for chemicals, streams in streams_by_chemicals.items():
+            stream_tables.append(report.stream_table(streams, chemicals=chemicals, T='K', **stream_properties))
+        report.tables_to_excel(report.stream_tables, writer, 'Stream table')
+        
+        # Heat utility tables
+        heat_utilities = report.heat_utility_tables(cost_units)
+        n_row = report.tables_to_excel(heat_utilities, writer, 'Utilities')
+        
+        # Power utility table
+        power_utility = report.power_utility_table(cost_units)
+        power_utility.to_excel(writer, 'Utilities', 
+                               index_label='Electricity',
+                               startrow=n_row)
+        
+        # General desing requirements
+        results = report.unit_result_tables(cost_units)
+        report.tables_to_excel(results, writer, 'Design requirements')
+        
+        # Reaction tables
+        reactions = report.unit_reaction_tables(units)
+        report.tables_to_excel(reactions, writer, 'Reactions')
+        
+        writer.save()
+        if diagram_completed: os.remove("flowsheet.png")
+
     # Debugging
     def _turn_on(self, mode):
         """Turn on special simulation modes like `profile` or `debug`."""
diff --git a/biosteam/_tea.py b/biosteam/_tea.py
index aad5c1e26..7cd3d103c 100644
--- a/biosteam/_tea.py
+++ b/biosteam/_tea.py
@@ -8,6 +8,7 @@
 # for license details.
 """
 """
+from __future__ import annotations
 import pandas as pd
 import numpy as np
 import flexsolve as flx
@@ -16,6 +17,10 @@
 from math import ceil
 from warnings import warn
 import biosteam as bst
+from typing import Optional, Sequence, Collection, TYPE_CHECKING
+from ._unit import Unit
+from numpy.typing import NDArray
+if TYPE_CHECKING: from ._system import System
 
 __all__ = ('TEA',)
 
@@ -225,18 +230,18 @@ class TEA:
     
     **Abstract methods**
     
-    _DPI(installed_equipment_cost) -> DPI
-        Should return the direct permanent investment given the
+    _DPI(installed_equipment_cost) -> float
+        Should return the direct permanent investment (DPI) given the
         installed equipment cost.
-    _TDC(DPI) -> TDC
-        Should take direct permanent investment as an argument
-        and return total depreciable capital.
-    _FCI(TDC) -> FCI
-        Should take total depreciable capital as an argument and return
-        fixed capital investment.
-    _FOC(FCI) -> FOC
-        Should take fixed capital investment as an arguments and return
-        fixed operating cost without depreciation. 
+    _TDC(DPI) -> float
+        Should take direct permanent investment (DPI) as an argument
+        and return total depreciable capital (TDC).
+    _FCI(TDC) -> float
+        Should take total depreciable capital (TDC) as an argument and return
+        fixed capital investment (FCI).
+    _FOC(FCI) -> float
+        Should take fixed capital investment (FCI) as an arguments and return
+        fixed operating cost without depreciation (FOC). 
     _fill_tax_and_incentives(incentives, taxable_cashflow, nontaxable_cashflow, tax)
         Should take two empty 1d arrays and fill them with incentive and tax cash flows.
         Additional parameters include taxable_cashflow (sales - costs - 
@@ -245,46 +250,46 @@ class TEA:
     
     Parameters
     ----------
-    system : System
+    system : 
         Should contain feed and product streams.
-    IRR : float
+    IRR : 
         Internal rate of return (fraction).
-    duration : tuple[int, int]
+    duration : 
         Start and end year of venture (e.g. (2018, 2038)).
-    depreciation : array or str
+    depreciation : 
         Depreciation schedule array or a string with format '{schedule}{years}', 
         where years is the number of years until the property value is zero 
         and schedule is one of the following: 'MACRS' (Modified Accelerated Cost Recovery System), 
         'SL' (straight line), 'DDB' (double declining balance), or 
         'SYD' (sum-of-the-years' digits). If years is not given, it defaults 
         to the venture years at run time. 
-    operating_days : float 
+    operating_days :  
         Number of operating days per year.
-    income_tax : float
+    income_tax : 
         Combined federal and state income tax rate (fraction).
-    lang_factor : float
+    lang_factor : 
         Lang factor for getting fixed capital investment
         from total purchase cost. If no lang factor, estimate
         capital investment using bare module factors.
-    construction_schedule : 1d array [float]
+    construction_schedule : 
         Construction investment fractions per year (e.g. (0.5, 0.5) for 50%
         capital investment in the first year and 50% investment in the second).
-    startup_months : float
+    startup_months : 
         Startup time in months.
-    startup_FOCfrac : float
+    startup_FOCfrac : 
         Fraction of fixed operating costs incurred during startup.
-    startup_VOCfrac : float
+    startup_VOCfrac : 
         Fraction of variable operating costs incurred during startup.
-    startup_salesfrac : float
+    startup_salesfrac : 
         Fraction of sales achieved during startup.
-    WC_over_FCI : float
+    WC_over_FCI : 
         Working capital as a fraction of fixed capital investment.
-    finanace_interest : float
+    finance_interest : 
         Yearly interest of capital cost financing as a fraction.
-    finance_years : int
-                    Number of years the loan is paid for.
-    finance_fraction : float
-                       Fraction of capital cost that needs to be financed.
+    finance_years : 
+        Number of years the loan is paid for.
+    finance_fraction :
+        Fraction of capital cost that needs to be financed.
     
     Warning
     -------
@@ -309,10 +314,10 @@ class TEA:
                  '_years', '_duration', '_start',  'IRR', '_IRR', '_sales',
                  '_duration_array_cache')
     
-    # Defaults include modified accelerated cost recovery system from
-    # U.S. IRS publicaiton 946 (MACRS), half-year convention
-    #: dict[tuple(str, int), 1d-array] Available depreciation schedules.
-    depreciation_schedules = {
+    #: Available depreciation schedules. Defaults include modified 
+    #: accelerated cost recovery system from U.S. IRS publication 946 (MACRS),
+    #: half-year convention.
+    depreciation_schedules: dict[tuple(str, int), NDArray[float]] = {
         ('MACRS', 3): np.array([.3333, .4445, .1481, .0741]),
 
         ('MACRS', 5): np.array([.2000, .3200, .1920,
@@ -343,11 +348,11 @@ class TEA:
                                  0.04462, 0.04461, 0.02231])
     }
     
-    #: dict[str, float] Investment site factors used to multiply the total permanent 
+    #: Investment site factors used to multiply the total permanent 
     #: investment (TPI), also known as total fixed capital (FCI), to 
     #: account for locality cost differences based on labor availability,
     #: workforce efficiency, local rules, etc.
-    investment_site_factors = {
+    investment_site_factors: dict[str, float] = {
         'U.S. Gulf Coast': 1.0,
         'U.S. Southwest': 0.95,
         'U.S. Northwest': 1.10,
@@ -378,13 +383,15 @@ def copy(self, system=None):
             system._TEA = new
         return new
 
-    def __init__(self, system, IRR, duration, depreciation, income_tax,
-                operating_days, lang_factor, construction_schedule,
-                startup_months, startup_FOCfrac, startup_VOCfrac,
-                startup_salesfrac, WC_over_FCI,  finance_interest,
-                finance_years, finance_fraction):
-        #: [System] System being evaluated.
-        self.system = system
+    def __init__(self, system: System, IRR: float, duration: tuple[int, int], 
+                 depreciation: str|NDArray[float], income_tax: float,
+                operating_days: float, lang_factor: float|None, 
+                construction_schedule: Sequence[float],
+                startup_months: float, startup_FOCfrac: float, startup_VOCfrac: float,
+                startup_salesfrac: float, WC_over_FCI: float,  finance_interest: float,
+                finance_years: int, finance_fraction: float):
+        #: System being evaluated.
+        self.system: System = system
         
         self.duration = duration
         self.depreciation = depreciation
@@ -392,40 +399,40 @@ def __init__(self, system, IRR, duration, depreciation, income_tax,
         self.startup_months = startup_months
         self.operating_days = operating_days
         
-        #: [float]  Internal rate of return (fraction).
-        self.IRR = IRR
+        #: Internal rate of return (fraction).
+        self.IRR: float = IRR
         
-        #: [float] Combined federal and state income tax rate (fraction).
-        self.income_tax = income_tax
+        #: Combined federal and state income tax rate (fraction).
+        self.income_tax: float = income_tax
         
         self.lang_factor = lang_factor
         
-        #: [float] Fraction of fixed operating costs incurred during startup.
-        self.startup_FOCfrac = startup_FOCfrac
+        #: Fraction of fixed operating costs incurred during startup.
+        self.startup_FOCfrac: float = startup_FOCfrac
         
-        #: [float] Fraction of variable operating costs incurred during startup.
-        self.startup_VOCfrac = startup_VOCfrac
+        #: Fraction of variable operating costs incurred during startup.
+        self.startup_VOCfrac: float = startup_VOCfrac
         
-        #: [float] Fraction of sales achieved during startup.
-        self.startup_salesfrac = startup_salesfrac
+        #: Fraction of sales achieved during startup.
+        self.startup_salesfrac: float = startup_salesfrac
         
-        #: [float] Working capital as a fraction of fixed capital investment.
-        self.WC_over_FCI = WC_over_FCI
+        #: Working capital as a fraction of fixed capital investment.
+        self.WC_over_FCI: float = WC_over_FCI
         
-        #: [float] Yearly interest of capital cost financing as a fraction.
-        self.finance_interest = finance_interest
+        #: Yearly interest of capital cost financing as a fraction.
+        self.finance_interest: float = finance_interest
         
-        #: [int] Number of years the loan is paid for.
-        self.finance_years = finance_years
+        #: Number of years the loan is paid for.
+        self.finance_years: int = finance_years
         
-        #: [float] Fraction of capital cost that needs to be financed.
-        self.finance_fraction = finance_fraction
+        #: Fraction of capital cost that needs to be financed.
+        self.finance_fraction: float = finance_fraction
         
         #: Guess IRR for solve_IRR method
-        self._IRR = IRR
+        self._IRR: float = IRR
         
         #: Guess cost for solve_price method
-        self._sales = 0
+        self._sales: float = 0
         
         #: For convenience, set a TEA attribute for the system
         system._TEA = self
@@ -443,41 +450,41 @@ def _FCI(self, TDC):
         return TDC # For compatibility with Lang factors
 
     @property
-    def units(self):
-        """set[Unit] All unit operations with costs."""
+    def units(self) -> set[Unit]:
+        """All unit operations with costs."""
         return self.system.cost_units  
 
     @property
-    def feeds(self):
-        """list[Unit] All feed streams."""
+    def feeds(self) -> list[Unit]:
+        """All feed streams."""
         return self.system.feeds  
       
     @property
-    def products(self):
-        """list[Unit] All product streams."""
+    def products(self) -> list[Unit]:
+        """All product streams."""
         return self.system.products
 
     @property
-    def operating_days(self):
-        """[float] Number of operating days per year."""
+    def operating_days(self) -> float:
+        """Number of operating days per year."""
         return self.system.operating_hours / 24
     @operating_days.setter
     def operating_days(self, days):
-        """[float] Number of operating days per year."""
+        """Number of operating days per year."""
         self.operating_hours = 24 * days
     
     @property
-    def operating_hours(self):
-        """[float] Number of operating hours per year."""
+    def operating_hours(self) -> float:
+        """Number of operating hours per year."""
         return self.system.operating_hours
     @operating_hours.setter
     def operating_hours(self, hours):
         self.system.operating_hours = hours
     
     @property
-    def lang_factor(self):
+    def lang_factor(self) -> float|None:
         """
-        [float] Lang factor for getting fixed capital investment from 
+        Lang factor for getting fixed capital investment from 
         total purchase cost. If no lang factor, estimate capital investment 
         using bare module factors.
         
@@ -488,8 +495,8 @@ def lang_factor(self, lang_factor):
         self.system.lang_factor = lang_factor
     
     @property
-    def duration(self):
-        """tuple[int, int] Start and end year of venture."""
+    def duration(self) -> tuple[int, int]:
+        """Start and end year of venture."""
         return self._duration
     @duration.setter
     def duration(self, duration):
@@ -498,9 +505,9 @@ def duration(self, duration):
         self._years = end - start
 
     @property
-    def depreciation(self):
+    def depreciation(self) -> str|NDArray[float]:
         """
-        [array or str] Depreciation schedule array or a string with format '{schedule}{years}', 
+        Depreciation schedule array or a string with format '{schedule}{years}', 
         where years is the number of years until the property value is zero 
         and schedule is one of the following: 'MACRS' (Modified Accelerated Cost Recovery System), 
         'SL' (straight line), 'DDB' (double declining balance), or 
@@ -564,8 +571,10 @@ def _depreciation_array_from_key(cls, key):
             return arr
     
     @property
-    def construction_schedule(self):
-        """tuple[float] Construction investment fractions per year, starting from year 0. For example, for 50% capital investment in year 0 and 50% investment in year 1: (0.5, 0.5)."""
+    def construction_schedule(self) -> Sequence[float]:
+        """Construction investment fractions per year, starting from year 0.
+        For example, for 50% capital investment in year 0 and 50% investment 
+        in year 1, use (0.5, 0.5)."""
         return self._construction_schedule
     @construction_schedule.setter
     def construction_schedule(self, schedule):
@@ -573,7 +582,7 @@ def construction_schedule(self, schedule):
         self._start = len(schedule)
     
     @property
-    def startup_months(self):
+    def startup_months(self) -> float:
         return self._startup_time * 12.
     @startup_months.setter
     def startup_months(self, months):
@@ -581,71 +590,71 @@ def startup_months(self, months):
         self._startup_time = months/12.
     
     @property
-    def sales(self):
-        """Total sales (USD/yr)."""
+    def sales(self) -> float:
+        """Total sales [USD/yr]."""
         return self.system.sales
     @property
-    def material_cost(self):
-        """Total material cost (USD/yr)."""
+    def material_cost(self) -> float:
+        """Total material cost [USD/yr]."""
         return self.system.material_cost
     @property
-    def utility_cost(self):
-        """Total utility cost (USD/yr)."""
+    def utility_cost(self) -> float:
+        """Total utility cost [USD/yr]."""
         return self.system.utility_cost
     @property
     def purchase_cost(self):
-        """Total purchase cost (USD)."""
+        """Total purchase cost [USD]."""
         return self.system.purchase_cost
     @property
-    def installed_equipment_cost(self):
-        """Total installed cost (USD)."""
+    def installed_equipment_cost(self) -> float:
+        """Total installed cost [USD]."""
         return self.system.installed_equipment_cost
     @property
-    def DPI(self):
-        """Direct permanent investment."""
+    def DPI(self) -> float:
+        """Direct permanent investment [USD]."""
         return self._DPI(self.installed_equipment_cost)
     @property
-    def TDC(self):
-        """Total depreciable capital."""
+    def TDC(self) -> float:
+        """Total depreciable capital [USD]."""
         return self._TDC(self.DPI)
     @property
-    def FCI(self):
-        """Fixed capital investment."""
+    def FCI(self) -> float:
+        """Fixed capital investment [USD]."""
         return self._FCI(self.TDC)
     @property
-    def TCI(self):
-        """Total capital investment."""
+    def TCI(self) -> float:
+        """Total capital investment [USD]."""
         return (1. + self.WC_over_FCI)*self.FCI
     @property
-    def FOC(self):
-        """Fixed operating costs (USD/yr)."""
+    def FOC(self) -> float:
+        """Fixed operating costs [USD/yr]."""
         return self._FOC(self.FCI)
     @property
-    def VOC(self):
-        """Variable operating costs (USD/yr)."""
+    def VOC(self) -> float:
+        """Variable operating costs [USD/yr]."""
         return self.material_cost + self.utility_cost
     @property
-    def AOC(self):
-        """Annual operating cost excluding depreciation (USD/yr)."""
+    def AOC(self) -> float:
+        """Annual operating cost excluding depreciation [USD/yr]."""
         return self.FOC + self.VOC
     @property
-    def working_capital(self):
+    def working_capital(self) -> float:
         return self.WC_over_FCI * self.FCI
     
     @property
-    def annual_depreciation(self):
-        """Depreciation (USD/yr) equivalent to TDC dived by the the duration of the venture."""
+    def annual_depreciation(self) -> float:
+        """Depreciation [USD/yr] equivalent to TDC dived by the the duration of the venture."""
         return self.TDC/(self.duration[1]-self.duration[0])
 
     @property
-    def ROI(self):
-        """Return on investment (1/yr) without accounting for annualized depreciation."""
+    def ROI(self) -> float:
+        """Return on investment [1/yr] without accounting for annualized depreciation."""
         FCI = self.FCI
         net_earnings = self.net_earnings
         TCI = FCI*(1.+self.WC_over_FCI)
         return net_earnings/TCI
     @property
-    def net_earnings(self):
+    def net_earnings(self) -> float:
         """Net earnings without accounting for annualized depreciation."""
         net_earnings = self.sales - self.AOC
         if net_earnings < 0:
@@ -653,8 +662,8 @@ def net_earnings(self):
         else:
             return (1 - self.income_tax) * net_earnings
     @property
-    def PBP(self):
-        """Pay back period (yr) without accounting for annualized depreciation."""
+    def PBP(self) -> float:
+        """Pay back period [yr] without accounting for annualized depreciation."""
         FCI = self.FCI
         net_earnings = self.net_earnings
         return FCI/net_earnings
@@ -763,7 +772,7 @@ def get_cashflow_table(self):
                             index=np.arange(self._duration[0]-start, self._duration[1]),
                             columns=cashflow_columns)
     @property
-    def NPV(self):
+    def NPV(self) -> float:
         """Net present value."""
         taxable_cashflow, nontaxable_cashflow, depreciation = self._taxable_nontaxable_depreciation_cashflows()
         tax = np.zeros_like(taxable_cashflow)
@@ -831,24 +840,25 @@ def _net_earnings_and_nontaxable_cashflow_arrays(self):
         return net_earnings, nontaxable_cashflow
     
     @property
-    def cashflow_array(self):
-        """[1d array] Cash flows by year."""
+    def cashflow_array(self) -> NDArray[float]:
+        """Cash flows by year."""
         return sum(self._net_earnings_and_nontaxable_cashflow_arrays())
     
     @property
-    def net_earnings_array(self):
-        """[1d array] Net earnings by year."""
+    def net_earnings_array(self) -> NDArray[float]:
+        """Net earnings by year."""
         return self._net_earnings_and_nontaxable_cashflow_arrays()[0]
     
-    def production_costs(self, products, with_annual_depreciation=True):
+    def production_costs(self, products: Sequence[bst.Stream], with_annual_depreciation: Optional[bool]=True):
         """
         Return production cost of products [USD/yr].
         
         Parameters
         ----------
-        products : Iterable[:class:`~thermosteam.Stream`]
-            Main products of the system
-        with_annual_depreciation=True : bool, optional
+        products : 
+            Main products of the system.
+        with_annual_depreciation: 
+            Whether to add annualized depreciation to the production costs.
         
         Notes
         -----
@@ -856,6 +866,7 @@ def production_costs(self, products, with_annual_depreciation=True):
         proportionally allocated to each of the main products with respect to
         their marketing values. The marketing value of each product is
         determined by the annual production multiplied by its selling price.
+        
         """
         system = self.system
         market_values = np.array([system.get_market_value(i) for i in products])
@@ -863,15 +874,16 @@ def production_costs(self, products, with_annual_depreciation=True):
         weights = market_values/total_market_value
         return weights * self.total_production_cost(products, with_annual_depreciation)
         
-    def total_production_cost(self, products, with_annual_depreciation):
+    def total_production_cost(self, products: Collection[bst.Stream], with_annual_depreciation: Optional[bool]=True):
         """
         Return total production cost of products [USD/yr].
         
         Parameters
         ----------
-        products : Iterable[:class:`~thermosteam.Stream`]
-                    Main products of the system
-        with_annual_depreciation=True : bool, optional
+        products : 
+            Main products of the system.
+        with_annual_depreciation: 
+            Whether to add annualized depreciation to the production costs.
         
         """
         system = self.system
@@ -896,14 +908,14 @@ def solve_IRR(self):
         self._IRR = IRR
         return IRR
         
-    def solve_price(self, streams):
+    def solve_price(self, streams: bst.Stream|Collection[bst.Stream]):
         """
-        Return the price (USD/kg) of a stream(s) at the break even point (NPV = 0)
+        Return the price [USD/kg] of a stream(s) at the break even point (NPV = 0)
         through cash flow analysis. 
         
         Parameters
         ----------
-        streams : tuple[:class:`~thermosteam.Stream`] or :class:`~thermosteam.Stream`
+        streams :
             Streams with variable selling price.
             
         """
@@ -925,7 +937,7 @@ def solve_price(self, streams):
         
     def solve_sales(self):
         """
-        Return the required additional sales (USD) to reach the breakeven 
+        Return the required additional sales [USD] to reach the breakeven 
         point (NPV = 0) through cash flow analysis. 
         
         """
diff --git a/biosteam/_unit.py b/biosteam/_unit.py
index a64ecc90d..768e6afc3 100644
--- a/biosteam/_unit.py
+++ b/biosteam/_unit.py
@@ -12,7 +12,6 @@
 import pandas as pd
 from warnings import warn
 from ._graphics import UnitGraphics, box_graphics
-from thermosteam import Stream
 from ._heat_utility import HeatUtility
 from .utils import AbstractMethod, format_title, static, piping, StreamLinkOptions
 from ._power_utility import PowerUtility
@@ -21,9 +20,10 @@
 from thermosteam.units_of_measure import convert
 from copy import copy
 import biosteam as bst
-import thermosteam as tmo
+from thermosteam import Stream
 from typing import Callable, Optional, TYPE_CHECKING, Sequence
 from numpy.typing import NDArray
+import thermosteam as tmo
 if TYPE_CHECKING: System = bst.System
 
 __all__ = ('Unit',)
@@ -164,6 +164,7 @@ def __init_subclass__(cls,
             elif 'tank' in line: cls.ticket_name = 'T'
             elif 'junction' == line: cls.ticket_name = 'J'
             elif 'specification' in line: cls.ticket_name = 'PS'
+            elif 'valve' in line: cls.ticket_name = 'V'
             else: cls.ticket_name = 'U'
         if '_graphics' not in dct and new_graphics:
             # Set new graphics for specified line
@@ -224,7 +225,7 @@ def __init_subclass__(cls,
     #: without having to add these costs in the :attr:`~Unit.baseline_purchase_costs` dictionary.
     #: Utility costs, however, are not automatically accounted for and must
     #: be hardcoded in the unit operation logic.
-    auxiliary_unit_names: tuple[str] = ()
+    auxiliary_unit_names: tuple[str, ...] = ()
     
     #: **class-attribute** Expected number of inlet streams. Defaults to 1.
     _N_ins: int = 1  
@@ -267,7 +268,7 @@ def __init_subclass__(cls,
     #: Create auxiliary components.
     _load_components = AbstractMethod
     
-    #: Run mass and energy balances and update outlet streams.
+    #: Run mass and energy balances and update outlet streams (without user-defined specifications).
     _run = AbstractMethod
     
     #: Add design requirements to the :attr:`~Unit.design_results` dictionary.
@@ -296,7 +297,7 @@ def __init__(self, ID: Optional[str]='', ins=None, outs=(), thermo: tmo.Thermo=N
         #: All heat utilities associated to unit. Cooling and heating requirements 
         #: are stored here (including auxiliary requirements). The number of heat utilities created is given by the
         #: class attribute :attr:`~Unit._N_heat_utilities`.
-        self.heat_utilities: tuple[HeatUtility] = tuple([HeatUtility() for i in range(self._N_heat_utilities)])
+        self.heat_utilities: tuple[HeatUtility, ...] = tuple([HeatUtility() for i in range(self._N_heat_utilities)])
         
         #: Electric utility associated to unit (including auxiliary requirements).
         self.power_utility: PowerUtility = PowerUtility()
@@ -437,6 +438,8 @@ def define_utility(self, name: str, stream: Stream):
         """
         Define an inlet or outlet stream as a utility by name.
         
+        Parameters
+        ----------
         name : 
             Name of utility, as defined in :data:`~biosteam.stream_utility_prices`.
         stream :
@@ -917,7 +920,16 @@ def add_bounded_numerical_specification(self, f=None, *args, **kwargs):
         return f
     
     def run(self):
-        """Run mass and energy balance."""
+        """
+        Run mass and energy balance with specifications.
+        
+        See Also
+        --------
+        _run
+        add_specification
+        add_bounded_numerical_specification
+        
+        """
         specification = self._specification
         if specification and not self._running_specification:
             self._running_specification = True
@@ -969,7 +981,7 @@ def _reevaluate(self):
         self._summary()
     
     def _summary(self):
-        """Calculate all results from unit run."""
+        """Run design and cost algorithms and compile capital and utility costs."""
         if not (self._design or self._cost): return
         self._design()
         self._cost()
@@ -986,7 +998,9 @@ def _summary(self):
     
     @property
     def specification(self) -> list[tuple[Callable, tuple]]:
-        """Process specification."""
+        """Process specifications as a list of specification functions and their 
+        arguments in the following format, [(<function0(*args0)>, args0), 
+        (<function1(*args1)>, args1), ...]."""
         return self._specification
     @specification.setter
     def specification(self, specification):
@@ -1030,7 +1044,7 @@ def utility_cost(self) -> float:
             return self._utility_cost
 
     @property
-    def auxiliary_units(self) -> tuple[Unit]:
+    def auxiliary_units(self) -> tuple[Unit, ...]:
         """All associated auxiliary units."""
         getfield = getattr
         return tuple([getfield(self, i) for i in self.auxiliary_unit_names])
@@ -1275,18 +1289,27 @@ def get_upstream_units(self, ends=None, facilities=True):
             new_length = len(upstream_units)
         return upstream_units
     
-    def neighborhood(self, radius=1, upstream=True, downstream=True, ends=None, facilities=None):
+    def neighborhood(self, 
+            radius: Optional[int]=1, upstream: Optional[bool]=True,
+            downstream: Optional[bool]=True, 
+            ends: Optional[Stream]=None, 
+            facilities: Optional[bool]=None
+        ):
         """
         Return a set of all neighboring units within given radius.
         
         Parameters
         ----------
-        radius : int
-                 Maxium number streams between neighbors.
-        downstream=True : bool, optional
-            Whether to include downstream operations
-        upstream=True : bool, optional
-            Whether to include upstream operations
+        radius : 
+            Maximum number streams between neighbors.
+        downstream : 
+            Whether to include downstream operations.
+        upstream : 
+            Whether to include upstream operations.
+        ends :
+            Streams that mark the end of the neighborhood.
+        facilities :
+            Whether to include facilities.
         
         """
         radius -= 1
@@ -1305,26 +1328,31 @@ def neighborhood(self, radius=1, upstream=True, downstream=True, ends=None, faci
             neighborhood.update(direct_neighborhood)
         return neighborhood
 
-    def diagram(self, radius=0, upstream=True, downstream=True, 
-                file=None, format='png', display=True, **graph_attrs):
+    def diagram(self, radius: Optional[int]=0, upstream: Optional[bool]=True,
+                downstream: Optional[bool]=True, file: Optional[str]=None, 
+                format: Optional[str]='png', display: Optional[bool]=True,
+                **graph_attrs):
         """
         Display a `Graphviz <https://pypi.org/project/graphviz/>`__ diagram
         of the unit and all neighboring units within given radius.
         
         Parameters
         ----------
-        radius : int
-                 Maximum number streams between neighbors.
-        downstream=True : bool, optional
-            Whether to show downstream operations
-        upstream=True : bool, optional
-            Whether to show upstream operations
-        file : Must be one of the following:
+        radius : 
+            Maximum number streams between neighbors.
+        downstream : 
+            Whether to show downstream operations.
+        upstream : 
+            Whether to show upstream operations.
+        file : 
+            Must be one of the following:
+            
             * [str] File name to save diagram.
             * [None] Display diagram in console.
-        format : str
-                 Format of file.
-        display : bool, optional
+            
+        format : 
+            Format of file.
+        display : 
             Whether to display diagram in console or to return the graphviz 
             object.
         
diff --git a/biosteam/digraph/digraph.py b/biosteam/digraph/digraph.py
index aeac889f4..da458981d 100644
--- a/biosteam/digraph/digraph.py
+++ b/biosteam/digraph/digraph.py
@@ -189,8 +189,8 @@ def digraph_from_system(system, **graph_attrs):
     f = blank_digraph(**graph_attrs) 
     other_streams = set()
     excluded_connections = set()
-    unit_names = get_unit_names(f, system.unit_path)
-    update_digraph_from_path(f, tuple(system.path) + system.facilities, 
+    unit_names = get_unit_names(f, (*system.path, *system.facilities))
+    update_digraph_from_path(f, (*system.path, *system.facilities), 
                              system.recycle, 0, unit_names, excluded_connections,
                              other_streams)
     connections = get_all_connections(other_streams).difference(excluded_connections)
@@ -236,7 +236,7 @@ def update_digraph_from_path(f, path, recycle, depth, unit_names,
         kwargs = dict(color=color, bgcolor='none', penwidth='0.75', style='solid')
     for i in subsystems:
         with f.subgraph(name='cluster_' + i.ID) as c:
-            c.attr(label=i.ID + f' [DEPTH {depth}]', fontname="Arial", 
+            c.attr(label=i.ID, fontname="Arial", 
                    labeljust='l', fontcolor=preferences.label_color, **kwargs)
             update_digraph_from_path(c, i.path, i.recycle, depth, unit_names, excluded_connections, other_streams)
 
@@ -245,22 +245,24 @@ def digraph_from_units_and_connections(units, connections, **graph_attrs):
     update_digraph_from_units_and_connections(f, units, connections)
     return f
 
-def get_unit_names(f: Digraph, units):
-    unit_names = {}  # Contains full description (ID and line) by unit
+def fill_info_from_path(path, indices, info_by_unit):
+    isa = isinstance
     number = preferences.number_path
     profile = preferences.profile
     TicToc = bst.utils.TicToc
-    info_by_unit = {}
-    N_junctions = 0
-    isa = isinstance
-    for i, u in enumerate(units):
+    for u in path:
         if isa(u, bst.Junction):
-            N_junctions += 1
             info_by_unit[u] = [[], None]
             continue
+        if isa(u, bst.System):
+            fill_info_from_path(u.path, [*indices, 0], info_by_unit)
+            indices[-1] += 1
+            continue
+        index = '.'.join([str(i) for i in indices])
+        indices[-1] += 1
         if u in info_by_unit:
             old_data = info_by_unit[u]
-            if number: old_data[0].append(str(i - N_junctions))
+            if number: old_data[0].append(index)
         else:
             if profile: # pragma: no cover
                 t = TicToc()
@@ -270,8 +272,12 @@ def get_unit_names(f: Digraph, units):
                 time = f"{1000 * t.mean:.2g} ms"
             else:
                 time = None
-            index = [str(i - N_junctions)] if number else []
-            info_by_unit[u] = [index, time] 
+            info_by_unit[u] = [[index] if number else [], time] 
+
+def get_unit_names(f: Digraph, path):
+    unit_names = {}  # Contains full description (ID and line) by unit
+    info_by_unit = {}
+    fill_info_from_path(path, [0], info_by_unit)
     for u, (index, time) in info_by_unit.items():
         node = u.get_node()
         name = node['name']
diff --git a/biosteam/evaluation/_model.py b/biosteam/evaluation/_model.py
index f57861065..38a30b7c8 100644
--- a/biosteam/evaluation/_model.py
+++ b/biosteam/evaluation/_model.py
@@ -182,12 +182,12 @@ def _load_sample_order(self, samples, parameters, ss, distance):
         samples_diff = samples_max - samples_min
         normalized_samples = (samples - samples_min) / samples_diff
         if ss: 
-            def evaluate(sample, **kwargs):
+            def evaluate(sample, material_data):
                 try:
                     self._parameters = parameters
                     for f, s in zip(self._parameters, sample): 
                         f.setter(s if f.scale is None else f.scale * s)
-                    diff = self._system.converge(**kwargs)
+                    diff = self._system.converge(material_data=material_data)
                 finally:
                     self._parameters = original_parameters
                 return diff
@@ -196,8 +196,7 @@ def evaluate(sample, **kwargs):
             index = range(N_parameters)
             evaluate(sample)
             material_data = self._system.get_material_data()
-            material_flows = material_data['material_flows']
-            N_elements = material_flows.size
+            N_elements = material_data.material_flows.size
             diffs = np.zeros([N_parameters, N_elements])
             for i in index:
                 sample_lb = sample.copy()
@@ -211,8 +210,8 @@ def evaluate(sample, **kwargs):
                 else:
                     sample_lb[i] = lb
                     sample_ub[i] = ub
-                lb = evaluate(sample_lb, **material_data).flatten()
-                ub = evaluate(sample_ub, **material_data).flatten()
+                lb = evaluate(sample_lb, material_data).flatten()
+                ub = evaluate(sample_ub, material_data).flatten()
                 diffs[i] = ub - lb
             div = diffs.max(axis=0)
             div[div == 0.] = 1
@@ -332,7 +331,7 @@ def single_point_sensitivity(self,
         if evaluate is None: evaluate = self._evaluate_sample
         baseline_1 = np.array(evaluate(sample, **kwargs))
         sys = self.system
-        if not sys.isdynamic: kwargs.update(sys.get_material_data())
+        if not sys.isdynamic: kwargs['material_data'] = sys.get_material_data()
         for i in index:
             sample_lb = sample.copy()
             sample_ub = sample.copy()
diff --git a/biosteam/process_tools/utils.py b/biosteam/process_tools/utils.py
index 885fd396a..5b39b9077 100644
--- a/biosteam/process_tools/utils.py
+++ b/biosteam/process_tools/utils.py
@@ -108,6 +108,7 @@ def rename_unit(unit, area):
     * S = Splitter (including solid/liquid separator)
     * T = Tank or bin for storage
     * U = Other units
+    * V = Valve
     * J = Junction, not a physical unit (serves to adjust streams)
     * PS = Process specificiation, not a physical unit (serves to adjust streams)
     
diff --git a/biosteam/report/table.py b/biosteam/report/table.py
index 8659222b8..da1e251dd 100644
--- a/biosteam/report/table.py
+++ b/biosteam/report/table.py
@@ -9,18 +9,15 @@
 """
 import numpy as np
 import pandas as pd
-from warnings import warn
-import openpyxl
 import thermosteam as tmo
 import biosteam as bst
 from .._heat_utility import HeatUtility
-import os
 
 DataFrame = pd.DataFrame
 ExcelWriter = pd.ExcelWriter
 
-__all__ = ('stream_table', 'cost_table', 'save_system_results',
-           'save_report', 'unit_result_tables', 'heat_utility_tables',
+__all__ = ('stream_table', 'cost_table',
+           'unit_result_tables', 'heat_utility_tables',
            'power_utility_table', 'tables_to_excel', 'voc_table',
            'lca_displacement_allocation_table', 
            'lca_inventory_table',
@@ -437,103 +434,6 @@ def tables_to_excel(tables, writer, sheet='Sheet1', n_row=1, row_spacing=2):
 
 # %% Units
 
-def save_report(system, file='report.xlsx', dpi='300', tea=None, **stream_properties): 
-    """
-    Save a system report as an xlsx file.
-    
-    Parameters
-    ----------
-    file : str
-        File name to save report
-    dpi : str, optional
-        Resolution of the flowsheet. Defaults to '300'
-    tea : TEA, optional
-        Object for techno-economic analysis and cashflows. Defaults to the
-        TEA object linked to the system.
-    **stream_properties : str
-        Additional stream properties and units as key-value pairs (e.g. T='degC', flow='gpm', H='kW', etc..)
-        
-    """
-    writer = ExcelWriter(file)
-    units = sorted(system.units, key=lambda x: x.line)
-    cost_units = [i for i in units if i._design or i._cost]
-    try:
-        with bst.preferences.temporary() as p:
-            p.reset()
-            p.light_mode()
-            system.diagram('thorough', file='flowsheet', dpi=str(dpi), format='png')
-    except:
-        diagram_completed = False
-        warn(RuntimeWarning('failed to generate diagram through graphviz'), stacklevel=2)
-    else:
-        import PIL.Image
-        try:
-            # Assume openpyxl is used
-            worksheet = writer.book.create_sheet('Flowsheet')
-            flowsheet = openpyxl.drawing.image.Image('flowsheet.png')
-            worksheet.add_image(flowsheet, anchor='A1')
-        except PIL.Image.DecompressionBombError:
-            PIL.Image.MAX_IMAGE_PIXELS = int(1e9)
-            flowsheet = openpyxl.drawing.image.Image('flowsheet.png')
-            worksheet.add_image(flowsheet, anchor='A1')
-        except:
-            # Assume xlsx writer is used
-            try:
-                worksheet = writer.book.add_worksheet('Flowsheet')
-            except:
-                warn("problem in saving flowsheet; please submit issue to BioSTEAM with"
-                     "your current version of openpyxl and xlsx writer", RuntimeWarning)
-            worksheet.insert_image('A1', 'flowsheet.png')
-        diagram_completed = True
-    
-    if tea is None: tea = system.TEA
-    if tea:
-        tea = system.TEA
-        cost = cost_table(tea)
-        cost.to_excel(writer, 'Itemized costs')
-        tea.get_cashflow_table().to_excel(writer, 'Cash flow')
-    else:
-        warn(f'Cannot find TEA object in {repr(system)}. Ignoring TEA sheets.',
-             RuntimeWarning, stacklevel=2)
-    
-    # Stream tables
-    # Organize streams by chemicals first
-    streams_by_chemicals = {}
-    for i in system.streams:
-        if not i: continue
-        chemicals = i.chemicals
-        if chemicals in streams_by_chemicals:
-            streams_by_chemicals[chemicals].append(i)
-        else:
-            streams_by_chemicals[chemicals] = [i]
-    stream_tables = []
-    for chemicals, streams in streams_by_chemicals.items():
-        stream_tables.append(stream_table(streams, chemicals=chemicals, T='K', **stream_properties))
-    tables_to_excel(stream_tables, writer, 'Stream table')
-    
-    # Heat utility tables
-    heat_utilities = heat_utility_tables(cost_units)
-    n_row = tables_to_excel(heat_utilities, writer, 'Utilities')
-    
-    # Power utility table
-    power_utility = power_utility_table(cost_units)
-    power_utility.to_excel(writer, 'Utilities', 
-                           index_label='Electricity',
-                           startrow=n_row)
-    
-    # General desing requirements
-    results = unit_result_tables(cost_units)
-    tables_to_excel(results, writer, 'Design requirements')
-    
-    # Reaction tables
-    reactions = unit_reaction_tables(units)
-    tables_to_excel(reactions, writer, 'Reactions')
-    
-    writer.save()
-    if diagram_completed: os.remove("flowsheet.png")
-
-save_system_results = save_report
-
 def unit_reaction_tables(units):
     isa = isinstance
     tables = []
diff --git a/biosteam/units/__init__.py b/biosteam/units/__init__.py
index ec2f122d2..965bcfbd7 100644
--- a/biosteam/units/__init__.py
+++ b/biosteam/units/__init__.py
@@ -37,6 +37,7 @@
 from ._carbon_capture import *
 from ._continuous_reactor import *
 from .compressor import *
+from .valve import *
 from .drying import *
 from .size_reduction import *
 from .size_enlargement import *
@@ -84,6 +85,7 @@
     _batch_crystallizer,
     _carbon_capture,
     compressor,
+    valve,
 )
 
 __all__ = ('Unit',
@@ -123,6 +125,7 @@
            *drying.__all__,
            *adsorption.__all__,
            *compressor.__all__,
+           *valve.__all__,
            'adsorption',
            'drying',
            'tank',
diff --git a/biosteam/units/valve.py b/biosteam/units/valve.py
new file mode 100644
index 000000000..5d3128dc2
--- /dev/null
+++ b/biosteam/units/valve.py
@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules
+# Copyright (C) 2020-2022, Yoel Cortes-Pena <yoelcortes@gmail.com>, Ben Portner <github.com/BenPortner>
+#
+# This module is under the UIUC open-source license. See
+# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt
+# for license details.
+"""
+.. contents:: :local:
+
+.. autoclass:: biosteam.units._valve.Valve
+.. autoclass:: biosteam.units._valve.IsenthalpicValve
+
+"""
+from .. import Unit
+from warnings import warn
+
+__all__ = (
+    'Valve',
+    'IsenthalpicValve',
+)
+
+class Valve(Unit, isabstract=True):
+    """
+    Abstract class for valves. Child classes should implement the `_run` 
+    method for mass and energy balances. No design or costing algorithms 
+    are implemented (yet). Any contributions to design and costing
+    is certainly welcome. For now, it is assumed that the cost of valves in 
+    a production process is negligible in relation to other unit operations. 
+    Additionally, valves serve a level of detail that is above the accuracy 
+    of cost correlations in BioSTEAM (which serve preliminary techno-economic 
+    analysis purposes).
+    
+    """
+
+class IsenthalpicValve(Valve):
+    """
+    Create an isenthalpic valve. Reduces the pressure of a fluid while keeping the enthalpy
+    constant (adiabatic flash). 
+
+    Parameters
+    ----------
+    ins : stream
+        Inlet fluid.
+    outs : stream
+        Outlet fluid.
+    P : float
+        Outlet pressure [Pa].
+    vle : bool
+        Whether to perform phase equilibrium calculations on
+        the outflow. If False, the outlet will be assumed to be the same
+        phase as the inlet.
+
+    Warnings
+    --------
+    No design or costing algorithms have been implemented (yet). For now, it 
+    is assumed that the cost of valves in a production process is negligible 
+    in relation to other unit operations. Additionally, valves serve a level of 
+    detail that is above the accuracy of cost correlations in BioSTEAM 
+    (which serve preliminary techno-economic analysis purposes).
+
+    """
+    _N_heat_utilities = 0
+
+    def __init__(self, ID='', ins=None, outs=(), thermo=None, *, P, vle=False):
+        Unit.__init__(self, ID, ins, outs, thermo)
+        self.P: float = P  #: Outlet pressure [Pa].
+
+        #: Whether to perform phase equilibrium calculations on the outflow.
+        #: If False, the outlet will be assumed to be the same phase as the inlet.
+        self.vle: bool = vle
+
+    def _run(self):
+        feed = self.ins[0]
+        out = self.outs[0]
+        out.copy_like(feed)
+        if feed.P > self.P:
+            if self.vle is True:
+                out.vle(H=feed.H, P=self.P)
+            else:
+                out.P = self.P
+                out.H = feed.H
+        else:
+            warn(f"feed pressure ({feed.P:.5g} Pa) is lower or equal than outlet "
+                 f"specification ({self.P:.5g} Pa); valve {self.ID} is ignored", RuntimeWarning)
diff --git a/docs/API/Facility.txt b/docs/API/Facility.txt
new file mode 100644
index 000000000..0e652cc2e
--- /dev/null
+++ b/docs/API/Facility.txt
@@ -0,0 +1,5 @@
+Facility
+========
+
+.. autoclass:: biosteam.Facility
+   :members:
\ No newline at end of file
diff --git a/docs/API/Flowsheet.txt b/docs/API/Flowsheet.txt
index 915eda93e..5bde3d4dc 100644
--- a/docs/API/Flowsheet.txt
+++ b/docs/API/Flowsheet.txt
@@ -3,3 +3,4 @@ Flowsheet
 
 .. autoclass:: biosteam.Flowsheet
    :members:
+   :special-members: __call__
diff --git a/docs/API/index.txt b/docs/API/index.txt
index 9144fccca..228c460e5 100644
--- a/docs/API/index.txt
+++ b/docs/API/index.txt
@@ -55,6 +55,7 @@ BioSTEAM's main components can be categorized by 4 functionality levels:
    :hidden:
    
    Unit
+   Facility
    PowerUtility
    UtilityAgent
    HeatUtility
diff --git a/docs/API/units/valve.txt b/docs/API/units/valve.txt
new file mode 100644
index 000000000..e83fbab66
--- /dev/null
+++ b/docs/API/units/valve.txt
@@ -0,0 +1,4 @@
+valve
+=====
+
+.. automodule:: biosteam.units.valve
\ No newline at end of file
diff --git a/docs/conf.py b/docs/conf.py
index 9c607476b..e311c2556 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -65,6 +65,113 @@
     'sphinx_autodoc_typehints',
     'nbsphinx']
 
+try:
+    import sphinx_autodoc_typehints as sat
+    def format_annotation(annotation, config) -> str:  # noqa: C901 # too complex
+        # Special cases
+        if isinstance(annotation, sat.ForwardRef):
+            return annotation.__forward_arg__
+        if annotation is None or annotation is type(None):  # noqa: E721
+            return ":py:obj:`None`"
+        if annotation is Ellipsis:
+            return ":py:data:`...<Ellipsis>`"
+    
+        if isinstance(annotation, tuple):
+            return sat.format_internal_tuple(annotation, config)
+    
+        try:
+            module = sat.get_annotation_module(annotation)
+            class_name = sat.get_annotation_class_name(annotation, module)
+            args = sat.get_annotation_args(annotation, module, class_name)
+        except ValueError:
+            return str(annotation).strip("'")
+    
+        # Redirect all typing_extensions types to the stdlib typing module
+        if module == "typing_extensions":
+            module = "typing"
+    
+        full_name = f"{module}.{class_name}" if module != "builtins" else class_name
+        fully_qualified: bool = getattr(config, "typehints_fully_qualified", False)
+        prefix = "" if fully_qualified or full_name == class_name else "~"
+        if module == "typing" and class_name in sat._PYDATA_ANNOTATIONS:
+            role = "data"
+        else:
+            role = "class"
+        args_format = "\\[{}]"
+        formatted_args: str | None = ""
+    
+        # Some types require special handling
+        if full_name == "typing.NewType":
+            args_format = f"\\(``{annotation.__name__}``, {{}})"
+            role = "class" if sys.version_info >= (3, 10) else "func"
+        elif full_name == "typing.TypeVar":
+            params = {k: getattr(annotation, f"__{k}__") for k in ("bound", "covariant", "contravariant")}
+            params = {k: v for k, v in params.items() if v}
+            if "bound" in params:
+                params["bound"] = f" {format_annotation(params['bound'], config)}"
+            args_format = f"\\(``{annotation.__name__}``{', {}' if args else ''}"
+            if params:
+                args_format += "".join(f", {k}={v}" for k, v in params.items())
+            args_format += ")"
+            formatted_args = None if args else args_format
+        elif full_name == "typing.Optional":
+            args = tuple(x for x in args if x is not type(None))  # noqa: E721
+        elif full_name in ("typing.Union", "types.UnionType") and type(None) in args:
+            if len(args) == 2:
+                full_name = "typing.Optional"
+                args = tuple(x for x in args if x is not type(None))  # noqa: E721
+            else:
+                simplify_optional_unions: bool = getattr(config, "simplify_optional_unions", True)
+                if not simplify_optional_unions:
+                    full_name = "typing.Optional"
+                    args_format = f"\\[:py:data:`{prefix}typing.Union`\\[{{}}]]"
+                    args = tuple(x for x in args if x is not type(None))  # noqa: E721
+        elif full_name == "typing.Callable" and args and args[0] is not ...:
+            fmt = [format_annotation(arg, config) for arg in args]
+            formatted_args = f"\\[\\[{', '.join(fmt[:-1])}], {fmt[-1]}]"
+        elif full_name == "typing.Literal":
+            formatted_args = f"\\[{', '.join(repr(arg) for arg in args)}]"
+        elif full_name == "types.UnionType":
+            return " | ".join([format_annotation(arg, config) for arg in args])
+    
+        if args and not formatted_args:
+            try:
+                iter(args)
+            except TypeError:
+                fmt = [format_annotation(args, config)]
+            else:
+                fmt = [format_annotation(arg, config) for arg in args]
+            formatted_args = args_format.format(", ".join(fmt))
+    
+        result = f":py:{role}:`{prefix}{full_name}`{formatted_args}"
+        return result
+    
+    def typehints_formatter(annotation, config):
+        # original = str(annotation).replace("'", "")
+        name = format_annotation(annotation, config)
+        if name.startswith('Optional['):
+            name = name.replace('Optional[', '')[:-1] + ', optional'
+        elif name.startswith(':py:data:`~typing.Optional`\['):
+            name = name.replace(':py:data:`~typing.Optional`\[', '')[:-1] + ', optional'
+        if not name.startswith(':py:class:') and not name.startswith(':py:data:'):
+            pyclass_added = False
+            for i in ['Iterable', 'Sequence', 'Collection', 'str', 'list', 'tuple', 'dict', 'int',
+                      'bool', 'set', 'frozenset', 'float']:
+                name = name.replace(i, f':py:class:`{i}`')
+                pyclass_added = True
+            for i in ['Unit', 'Stream', 'Facility', 'HeatUtility', 'PowerUtility', 'System', 'TEA', 'HXutility']:
+                name = name.replace(i, f':py:class:`~biosteam.{i}`')
+                pyclass_added = True
+            if pyclass_added: 
+                name = name.replace('[', '\[').replace(':py:class::py:class:', ':py:class:')
+        name = name.replace('bst.', '').replace('tmo.', '').replace('`biosteam', '`~biosteam').replace('._unit', '')
+        # file = os.path.join(os.path.dirname(__file__), 'annotations.txt')
+        # with open(file, 'a') as f: f.write(f"{name}  ({original})\n")
+        return name
+except:
+    pass
+
+simplify_optional_unions = True
 always_document_param_types = False
 typehints_document_rtype = False
 typehints_use_rtype = False
@@ -85,6 +192,10 @@
 # Specify the baseurls for the projects I want to link to
 intersphinx_mapping = {
     'scipy': ('https://docs.scipy.org/doc/scipy/reference/', None),
+    'python': ('https://docs.python.org/3', None),
+    'typing': ('https://docs.python.org/3/library', None),
+    'qsdsan': ('https://qsdsan.readthedocs.io/en/latest/', None),
+    'thermo': ('https://thermo.readthedocs.io/', None),
 }
 
 # Allow exceptions to occur in notebooks
diff --git a/docs/tutorial/Creating_a_System.ipynb b/docs/tutorial/Creating_a_System.ipynb
index cf8d02e10..1d4d78229 100644
--- a/docs/tutorial/Creating_a_System.ipynb
+++ b/docs/tutorial/Creating_a_System.ipynb
@@ -68,7 +68,7 @@
     "manual_sys.simulate()\n",
     "manual_sys.diagram(\n",
     "    kind='cluster', # Cluster diagrams highlight recycle streams and nested systems.\n",
-    "    number=True, # This numbers each unit according to their path order\n",
+    "    number=True, # This numbers each unit according to their path simulation order\n",
     ") "
    ]
   },
@@ -134,7 +134,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
@@ -149,6 +149,9 @@
     "M2 = bst.Mixer('M2', [P2-0, water])\n",
     "flowsheet_sys = bst.main_flowsheet.create_system('flowsheet_sys')\n",
     "flowsheet_sys.simulate()\n",
+    "\n",
+    "# Units in subsystems are numbered with after a \".\" to represent \n",
+    "# the subsystem depth (checkout SYS1 in the diagram)\n",
     "flowsheet_sys.diagram(kind='cluster', number=True)"
    ]
   },
@@ -272,7 +275,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
@@ -286,7 +289,7 @@
     "flowsheet_sys-0-context_sys \n",
     "complete_sys = bst.main_flowsheet.create_system('complete_sys')\n",
     "complete_sys.simulate()\n",
-    "complete_sys.diagram('cluster')"
+    "complete_sys.diagram('cluster', number=True)"
    ]
   },
   {
@@ -948,7 +951,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.5"
+   "version": "3.9.12"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorial/Getting_started.ipynb b/docs/tutorial/Getting_started.ipynb
index 1b9a73eb3..06a2df0e1 100644
--- a/docs/tutorial/Getting_started.ipynb
+++ b/docs/tutorial/Getting_started.ipynb
@@ -977,7 +977,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.5"
+   "version": "3.9.12"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorial/Gotchas.ipynb b/docs/tutorial/Gotchas.ipynb
index c620f9c0e..a68080963 100644
--- a/docs/tutorial/Gotchas.ipynb
+++ b/docs/tutorial/Gotchas.ipynb
@@ -252,7 +252,11 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbval-ignore-output"
+    ]
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -285,6 +289,7 @@
     "P1.simulate()\n",
     "# Note how, although inlet and outlet pressures are the same, the pump is assummed to work at a 4 atm pressure gain\n",
     "P1.outs[0].show() \n",
+    "print()\n",
     "print(P1.results())"
    ]
   },
diff --git a/requirements.txt b/requirements.txt
index 2c91c5b42..a76415212 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,4 @@
 sphinx>=4.2.0
-thermosteam>=0.28.12
 pydata_sphinx_theme
 sphinx_multitoc_numbering
 sphinx_autodoc_typehints
diff --git a/setup.py b/setup.py
index aa3e4ba14..a19c0e248 100644
--- a/setup.py
+++ b/setup.py
@@ -75,6 +75,8 @@
                  'Operating System :: POSIX :: Linux',
                  'Operating System :: Unix',
                  'Programming Language :: Python :: 3.8',
+                 'Programming Language :: Python :: 3.9',
+                 'Programming Language :: Python :: 3.10',
                  'Programming Language :: Python :: Implementation :: CPython',
                  'Topic :: Education'],
     keywords=['chemical process simmulation', 'bioprocess engineering', 'mass and energy balance', 'material properties', 'phase equilibrium', 'CABBI', 'biorefinery', 'biofuel', 'bioproducts'],
diff --git a/thermosteam b/thermosteam
index 4651e9167..0899d93c0 160000
--- a/thermosteam
+++ b/thermosteam
@@ -1,1 +1,1 @@
-Subproject commit 4651e91678ed5af6e2cc247fad44f06de6f98912
+Subproject commit 0899d93c0273283cf9ce4d5d73e82b6a9e7400ff


Test patch:
diff --git a/tests/test_autogenerated_system.py b/tests/test_autogenerated_system.py
index 04a9436f9..a2fb70caa 100644
--- a/tests/test_autogenerated_system.py
+++ b/tests/test_autogenerated_system.py
@@ -22,11 +22,11 @@ def test_trivial_case():
     f.set_flowsheet('trivial_case')
     settings.set_thermo(['Water'], cache=True)
     trivial_sys_a = f.create_system('trivial_sys_a')
-    network_a = trivial_sys_a.to_network()
+    network_a = trivial_sys_a._to_network()
     Stream('feedstock', Water=1000)
     Stream('water', Water=10)
     trivial_sys_b = f.create_system('trivial_sys_b')
-    network_b = trivial_sys_b.to_network()
+    network_b = trivial_sys_b._to_network()
     actual_network = Network(
         [])
     assert network_a == network_b == actual_network
@@ -47,7 +47,7 @@ def test_linear_case():
     M1 = Mixer('M1', [feedstock, water])
     S1 = Splitter('S1', M1-0, [product, byproduct], split=0.5)
     linear_sys = f.create_system('linear_sys')
-    network = linear_sys.to_network()
+    network = linear_sys._to_network()
     actual_network = Network(
         [M1,
          S1])
@@ -69,7 +69,7 @@ def test_simple_recycle_loop():
     M1 = Mixer('M1', [feedstock, water, recycle])
     S1 = Splitter('S1', M1-0, [product, recycle], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [M1,
          S1],
@@ -102,7 +102,7 @@ def test_unconnected_case():
     M1_b = Mixer('M1_b', [feedstock_b, water_b])
     S1_b = Splitter('S1_b', M1_b-0, [product_b, byproduct_b], split=0.5)
     parallel_sys = f.create_system('parallel_sys')
-    network = parallel_sys.to_network()
+    network = parallel_sys._to_network()
     actual_network = Network(
         [M1_a,
          S1_a,
@@ -134,7 +134,7 @@ def test_unconnected_recycle_loop():
     M1_b = Mixer('M1_b', [feedstock_b, water_b])
     S1_b = Splitter('S1_b', M1_b-0, [product_b, byproduct_b], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [Network(
             [M1_a,
@@ -154,7 +154,7 @@ def test_unconnected_recycle_loop():
     
     feedstock_b.F_mol = 1200 # Larger flow means b has higher priority
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [M1_b,
          S1_b,
@@ -190,7 +190,7 @@ def test_unconnected_recycle_loops():
     M1_b = Mixer('M1_b', [feedstock_b, water_b, recycle_b])
     S1_b = Splitter('S1_b', M1_b-0, [product_b, recycle_b], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [Network(
             [M1_a,
@@ -223,7 +223,7 @@ def test_inner_recycle_loop():
     M1 = Mixer('M1', [P1-0, P2-0, recycle])
     S1 = Splitter('S1', M1-0, [product, recycle], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [P1,
          P2,
@@ -258,7 +258,7 @@ def test_inner_recycle_loop_with_bifurcated_feed():
     M2 = Mixer('M2', [S1-0, S2-1])
     S3 = Splitter('S3', M2-0, [product, recycle], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [P1,
          P2,
@@ -306,7 +306,7 @@ def test_bifurcated_recycle_loops():
     M2_b = Mixer('M2_b', [S1_b-0, S2_b-1, S3_a-0])
     S3_b = Splitter('S3_b', M2_b-0, [product_b, recycle_b], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [P1_b,
          P1_a,
@@ -355,7 +355,7 @@ def test_two_recycle_loops_with_complete_overlap():
     S2 = Splitter('S2', M2-0, ['', inner_recycle], split=0.5)
     S1 = Splitter('S1', S2-0, [product, recycle], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [P1,
          P2,
@@ -398,7 +398,7 @@ def test_two_recycle_loops_with_partial_overlap():
     S3 = Splitter('S3', S2-0, [coproduct, inner_recycle], split=0.5)
     S1 = Splitter('S1', S2-1, [product, recycle], split=0.5)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [P1,
          P2,
@@ -452,7 +452,7 @@ def test_feed_forward_recycle_loop():
     S2 = Splitter('S2', M2-0, [inner_recycle, product], split=0.5)
     P3 = Pump('P3', product)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = (
         Network(
             [P1,
@@ -498,7 +498,7 @@ def test_separate_recycle_loops():
     recycles = [recycle_a, recycle_b]
     recycle_loop_sys = f.create_system('recycle_loop_sys')
     recycle_loop_sys.simulate()
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [P1_a,
          P2_a,
@@ -564,7 +564,7 @@ def test_nested_recycle_loops():
     M8 = Mixer('M8', [S3-1, S1-1, S5-0], product)
     recycle_loop_sys = f.create_system('recycle_loop_sys')
     recycle_loop_sys.simulate()
-    network = recycle_loop_sys.to_network()
+    network = recycle_loop_sys._to_network()
     actual_network = Network(
         [P1,
          P3,
@@ -612,7 +612,7 @@ def test_sugarcane_ethanol_biorefinery_network():
     from biorefineries.sugarcane import flowsheet as f
     sugarcane_sys = f.create_system('sugarcane_sys')
     globals().update(f.unit.data)
-    network = sugarcane_sys.to_network()
+    network = sugarcane_sys._to_network()
     actual_network = Network(
         [U101,
          U102,
diff --git a/tests/test_valve.py b/tests/test_valve.py
new file mode 100644
index 000000000..03871c698
--- /dev/null
+++ b/tests/test_valve.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# BioSTEAM: The Biorefinery Simulation and Techno-Economic Analysis Modules
+# Copyright (C) 2020-2021, Yoel Cortes-Pena <yoelcortes@gmail.com>
+# 
+# This module is under the UIUC open-source license. See 
+# github.com/BioSTEAMDevelopmentGroup/biosteam/blob/master/LICENSE.txt
+# for license details.
+"""
+"""
+import pytest
+import biosteam as bst
+from numpy.testing import assert_allclose
+
+
+def test_isenthalpic_methane_liquefaction():
+    thermo = bst.Thermo([bst.Chemical('CH4')])
+    thermo.mixture.include_excess_energies = True
+    bst.settings.set_thermo(thermo, cache=True)
+    feed = bst.Stream(CH4=1, T=-63 + 273.15, P=100e5, phase='g')
+    V = bst.units.IsenthalpicValve(ins=feed, P=1e5, vle=True)
+    V.simulate()
+    # check outlet state
+    out = V.outs[0]
+    assert_allclose(
+        [out.vapor_fraction, out.liquid_fraction, out.T, out.P, out.H],
+        [0.8353, 0.1646, 111.474, 1e5, feed.H],
+        rtol=1e-2,
+    )
+    pass
+
+
+if __name__ == '__main__':
+    test_isenthalpic_methane_liquefaction()