esclab 0.0.1__py3-none-any.whl

esclab/__init__.py

@@ -0,0 +1,8 @@
+# This file marks the src directory as a Python package.
+"""
+ESCLab: Engineering Simulation and Control Lab
+"""
+
+__version__ = "0.0.1"
+__author__ = "Mike Wagner"
+__email__ = "mjwagner2@wisc.edu"

esclab/components/__init__.py

@@ -0,0 +1,35 @@
+"""
+This file ensures that the component libraries are available for import from the top-level components module. 
+
+Add new modules to this file using:
+	from . import my_component_library
+    
+And add the module name to __all__ to make it available using the flat import syntax:
+	from esclab.components import my_component_library
+    or
+    from esclab.components import *
+
+It's best practice to import the component library as a named item, and then 
+reference the components through that namespace to avoid name collisions across libraries. For example:
+	import esclab.circuit_elements as ce
+	ce.Resistor(...)
+
+Import the submodule you need and reference components through it to avoid
+name collisions across libraries:
+
+    from esclab.components import circuit_elements
+    circuit_elements.TeeOut(...)
+
+"""
+
+from . import brayton_simple
+from . import circuit_elements
+from . import esol_properties
+from . import template_component
+
+__all__ = [
+    "brayton_simple",
+    "circuit_elements",
+    "esol_properties",
+    "template_component"
+]

esclab/components/brayton_simple.py

@@ -0,0 +1,123 @@
+from esclab.simulate import *
+from eeslib import fluid_properties
+import numpy as np
+
+# -------------------------------------------
+class Turbine(Component):
+
+    eta_s =    Component.Parameter(0.9)
+    mdot_in =  Component.Input()
+    T_in    =  Component.Input()
+    P_in    =  Component.Input()
+    h_out =    Component.Output()
+    T_out =    Component.Output()
+    P_out =    Component.Output()
+    mdot_out = Component.Output()
+    W =        Component.Output()
+    fluid = 'Air'
+
+    def calculate(self):
+        self.mdot_out = self.mdot_in
+        h_in = fluid_properties.enthalpy(self.fluid, T=self.T_in, P=self.P_in)
+        s_in = fluid_properties.entropy(self.fluid, T=self.T_in, P=self.P_in)
+        self.P_out = self.P_in / self.model.design.PR
+        h_out_s = fluid_properties.enthalpy(self.fluid,P=self.P_out, s=s_in)
+        self.h_out = h_in - (h_in-h_out_s)*self.eta_s
+        self.T_out = fluid_properties.temperature(self.fluid, P=self.P_out, h=self.h_out)
+        self.W = (h_in - self.h_out)*self.mdot_in        
+        return 
+    
+# -------------------------------------------
+class Compressor(Component):
+    eta_s = Component.Parameter(0.85)
+    PR = Component.Parameter(3.)
+
+    mdot_in = Component.Input()
+    T_in    = Component.Input()
+    P_in    = Component.Input()
+
+    h_out = Component.Output()
+    T_out = Component.Output()
+    P_out = Component.Output()
+    mdot_out = Component.Output()
+    W = Component.Output()
+
+    fluid = 'Air'
+        
+    def calculate(self):
+        self.mdot_out = self.mdot_in
+        h_in = fluid_properties.enthalpy(self.fluid, T=self.T_in, P=self.P_in)
+        s_in = fluid_properties.entropy(self.fluid, T=self.T_in, P=self.P_in)
+        self.P_out = self.P_in * self.PR
+        h_out_s = fluid_properties.enthalpy(self.fluid,P=self.P_out, s=s_in)
+        self.h_out = h_in + (h_out_s - h_in)/self.eta_s
+        self.T_out = fluid_properties.temperature(self.fluid, P=self.P_out, h=self.h_out)
+        self.W = (h_in - self.h_out)*self.mdot_in  
+        return 
+    
+# -------------------------------------------
+class Combustor(Component):
+    mdot_in = Component.Input()
+    T_in    = Component.Input()
+    P_in    = Component.Input()
+
+    h_out = Component.Output()
+    T_out = Component.Output()
+    P_out = Component.Output()
+    mdot_out = Component.Output()
+    qdot = Component.Output()
+
+    def presim_setup(self, **kwargs):
+        return super().presim_setup(**kwargs)
+
+    def calculate(self):
+        super().calculate()
+        self.mdot_out = self.mdot_in 
+        self.P_out = self.P_in 
+        self.T_out = self.model.design.T_turb_in
+        h_in = fluid_properties.enthalpy(self.model.design.fluid, T=self.T_in, P=self.P_in)
+        self.h_out = fluid_properties.enthalpy(self.model.design.fluid, T=self.T_out, P=self.P_out)
+        self.qdot = (self.h_out - h_in)*self.mdot_in
+        return 
+    
+# -------------------------------------------
+class Cooler(Component):
+    dT_approach = Component.Parameter(20)
+
+    mdot_in    = Component.Input()
+    T_in       = Component.Input()
+    P_in       = Component.Input()
+    T_amb      = Component.Input()
+
+    h_out = Component.Output()
+    T_out = Component.Output()
+    P_out = Component.Output()
+    mdot_out = Component.Output()
+    qdot = Component.Output()
+    
+    def calculate(self):
+        self.mdot_out = self.mdot_in
+        self.P_out = self.P_in
+        h_in = fluid_properties.enthalpy(self.model.design.fluid, T=self.T_in, P=self.P_in)
+        self.T_out = self.T_amb + self.dT_approach
+        self.h_out = fluid_properties.enthalpy(self.model.design.fluid, P=self.model.design.P_low, T=self.T_out)
+        self.qdot = (self.h_out - h_in)*self.mdot_in
+        return 
+
+class Summary(Component):
+    W_turbine = Component.Input()
+    W_compressor = Component.Input()
+    Q_combustor = Component.Input()
+    eta_cycle = Component.Output()
+    
+    def calculate(self):
+        self.eta_cycle = (self.W_turbine + self.W_compressor)/self.Q_combustor
+
+class Weather(Component):
+    def presim_setup(self):
+        self.T_amb = Component.Output()
+        return 
+
+    def calculate(self):
+        super().calculate()
+        self.T_amb = self.model.design.T_amb + 15*np.sin(self.model.time/1e5/np.pi) + 15*np.sin(self.model.time/1e5/np.pi*2+.5)

esclab/components/circuit_elements.py

@@ -0,0 +1,163 @@
+"""
+Circuit component library using simple models. 
+The components are set up to be compatible with the matrix inversion method.
+"""
+
+from esclab.simulate import *
+
+class __CircuitElement(Component):
+    """Base class for circuit elements."""
+    u_in = Component.Input()   # voltage
+    i_in = Component.Input()   # current
+
+    u_out = Component.Output()  # voltage
+    i_out = Component.Output()  # current
+
+    def calculate(self):
+        if self.coupled_eqs is not None:
+            # All series elements pass current straight through: i_out = i_in.
+            # Child classes call super().calculate() to contribute this equation,
+            # then add their own voltage equation(s).
+            self.coupled_eqs.add_equation({
+                self.i_out: 1.0,
+                self.coupled_eqs.source(self.i_in): -1.0,
+            }, rhs=0.0)
+
+class VoltageSource(__CircuitElement):
+    """Ideal voltage source element."""
+    V = Component.Parameter()  # source voltage
+    omega_hi = Component.Parameter(0)  # cutoff frequency for high-pass behavior
+    omega_lo = Component.Parameter(0)  # cutoff frequency for low-pass behavior
+
+    def __init__(self):
+        super().__init__()
+        self.V_t = self.V  # stored voltage for time-varying sources
+
+    def calculate(self):
+        super().calculate()  # i_out = i_in pass-through (only when coupled_eqs is set)
+        if self.coupled_eqs is not None:
+            V_t = 1
+            V_t += np.sin(2 * np.pi * self.omega_hi * self.model.time) * 0.25
+            V_t += np.sin(2 * np.pi * self.omega_lo * self.model.time) * 0.25
+            V_t += self.V * V_t
+            self.coupled_eqs.add_equation({
+                self.u_out: 1.0,
+                self.coupled_eqs.source(self.u_in): -1.0,
+            }, rhs=V_t)
+            self.coupled_eqs.add_equation({
+                self.coupled_eqs.source(self.u_in): 1.0,
+            }, rhs=0.0)
+
+
+class Resistor(__CircuitElement):
+    """Resistor element."""
+    R = Component.Parameter()  # resistance
+
+    def calculate(self):
+        super().calculate()  # i_out = i_in pass-through
+        if self.coupled_eqs is not None:
+            # u_out = u_in - R*i_in    =>    u_out - u_in + R*i_in = 0
+            self.coupled_eqs.add_equation({
+                self.u_out: 1.0,
+                self.coupled_eqs.source(self.u_in): -1.0,
+                self.coupled_eqs.source(self.i_in): self.R,
+            }, rhs=0.0)
+
+class Capacitor(__CircuitElement):
+    """Capacitor element."""
+    C = Component.Parameter()  # capacitance
+    U_C0 = Component.Parameter(0.)  # initial voltage across the capacitor
+
+    def presim_setup(self, **kwargs):
+        self.U_C_prev = self.U_C0  # stored capacitor voltage from previous timestep
+
+    def calculate(self):
+        super().calculate()  # i_out = i_in pass-through
+        dt = self.model.settings.timestep
+        if self.coupled_eqs is not None:
+            # Backward Euler: u_out = u_in - U_C_prev - (dt/C)*i_in
+            # u_out - u_in + (dt/C)*i_in = -U_C_prev
+            self.coupled_eqs.add_equation({
+                self.u_out: 1.0,
+                self.coupled_eqs.source(self.u_in): -1.0,
+                self.coupled_eqs.source(self.i_in): dt / self.C,
+            }, rhs=-self.U_C_prev)
+        elif self.model.is_converged:
+            # After convergence, store the capacitor voltage for the next timestep.
+            self.U_C_prev = self.U_C_prev + self.i_in * dt / self.C
+
+class Inductor(__CircuitElement):
+    """Inductor element."""
+    L = Component.Parameter()  # inductance
+    I_L0 = Component.Parameter(0.)  # initial current through the inductor
+
+    def presim_setup(self, **kwargs):
+        self.I_L_prev = self.I_L0  # stored inductor current from previous timestep
+
+    def calculate(self):
+        super().calculate()  # i_out = i_in pass-through
+        dt = self.model.settings.timestep
+        L = self.L
+        if self.coupled_eqs is not None:
+            # Backward Euler: u_out = u_in - (L/dt)*i_in + (L/dt)*I_L_prev
+            # u_out - u_in + (L/dt)*i_in = (L/dt)*I_L_prev
+            self.coupled_eqs.add_equation({
+                self.u_out: 1.0,
+                self.coupled_eqs.source(self.u_in): -1.0,
+                self.coupled_eqs.source(self.i_in): L / dt,
+            }, rhs=(L / dt) * self.I_L_prev)
+        elif self.model.is_converged:
+            # After convergence, store the inductor current for the next timestep.
+            self.I_L_prev = self.i_in
+
+
+class TeeOut(Component):
+    """Tee element for splitting voltage and current."""
+    u_in = Component.Input()   # voltage
+    i_in = Component.Input()   # current
+
+    u_out = Component.Output()  # voltage output
+    i_out_1 = Component.Output()  # current output 1
+    i_out_2 = Component.Output()  # current output 2
+
+    def calculate(self):
+        if self.coupled_eqs is not None:
+            # Current splits: i_in = i_out_1 + i_out_2
+            self.coupled_eqs.add_equation({
+                self.coupled_eqs.source(self.i_in): 1.0,
+                self.i_out_1: -1.0,
+                self.i_out_2: -1.0,
+            }, rhs=0.0)
+            # Output voltage equals input voltage: u_out = u_in
+            self.coupled_eqs.add_equation({
+                self.u_out: 1.0,
+                self.coupled_eqs.source(self.u_in): -1.0,
+            }, rhs=0.0)
+
+class TeeReturn(Component):
+    """Tee element for combining voltage and current."""
+    u_in_1 = Component.Input()  # voltage from branch 1
+    i_in_1 = Component.Input()  # current from branch 1
+    u_in_2 = Component.Input()  # voltage from branch 2
+    i_in_2 = Component.Input()  # current from branch 2
+
+    u_out = Component.Output()  # voltage output
+    i_out = Component.Output()  # current output
+
+    def calculate(self):
+        if self.coupled_eqs is not None:
+            # Current combines: i_out = i_in_1 + i_in_2
+            self.coupled_eqs.add_equation({
+                self.i_out: 1.0,
+                self.coupled_eqs.source(self.i_in_1): -1.0,
+                self.coupled_eqs.source(self.i_in_2): -1.0,
+            }, rhs=0.0)
+            # Output voltage equals both input voltages: u_out = u_in_1 = u_in_2
+            self.coupled_eqs.add_equation({
+                self.u_out: 1.0,
+                self.coupled_eqs.source(self.u_in_1): -1.0,
+            }, rhs=0.0)
+            self.coupled_eqs.add_equation({
+                self.u_out: 1.0,
+                self.coupled_eqs.source(self.u_in_2): -1.0,
+            }, rhs=0.0)

esclab/components/esol_properties.py

@@ -0,0 +1,215 @@
+from esclab.simulate import *
+from eeslib import fluid_properties as fp
+from eeslib.functions import convert
+import numpy as np
+
+"""
+Unified property database for incompressible fluids, including density, viscosity, and specific heat, where available.
+
+Note that some water properties are provided here, and other fluids that are potentially compressible (e.g. air, argon, hydrogen) are included with ideal gas density models. For more detailed and comprehensive property data, users should import **eeslib** which provides an API for CoolProp.
+
+Usage:
+    from esclab.components.esol_properties import Incompressible
+    props = Incompressible()
+    props.viscosity('Air', T=300)           # Viscosity of air at 300 K
+    props.specheat('Therminol Oil', T=350)  # Specific heat of Therminol Oil at 350 K
+    props.enthalpy('Salt (60 NaNO3, 40 KNO3)', T=400, T_ref=300)  # Enthalpy change of salt from 300 K to 400 K
+
+"""
+
+class Incompressible:
+    """Incompressible substance property database with density, viscosity, and specific heat, where available"""
+    
+    funcmap = {
+        "Stainless_AISI316": {
+            'density': (lambda T: 8349.38 - 0.341708*T - 0.0000865128*T*T),
+            'specheat': (lambda T: 0.368455 + 0.000399548*T - 1.70558E-07*T*T),
+        },
+        "Water (liquid)": {
+            # Use with caution - this is only valid near room temp/pressure
+            'density': (lambda T: 1000),
+            'specheat': (lambda T: 4.181),
+        },
+        "Air": {
+            'viscosity': (lambda T: max([0.0000010765 + 7.15173E-08*T - 5.03525E-11*T*T + 2.02799E-14*T*T*T, 1.e-6])),
+            'specheat': (lambda T: 1.03749 - 0.000305497*T + 7.49335E-07*T*T - 3.39363E-10*T*T*T),
+        },
+        "Salt (68 KCl, 32 MgCl2)": {
+            'density': (lambda T: 1E-10*T*T*T - 3E-07*T*T - 0.4739*T + 2384.2),
+            'viscosity': (lambda T: 0.0146*np.exp(2230./T)*0.001),
+            'specheat': (lambda T: 1.156),
+        },
+        "Salt (8 NaF, 92 NaBF4)": {
+            'density': (lambda T: 8E-09*T*T*T - 2E-05*T*T - 0.6867*T + 2438.5),
+            'viscosity': (lambda T: 0.0877*np.exp(2240./T)*0.001),
+            'specheat': (lambda T: 1.507),
+        },
+        "Salt (25 KF, 75 KBF4)": {
+            'density': (lambda T: 2E-08*T*T*T - 6E-05*T*T - 0.7701*T + 2466.1),
+            'viscosity': (lambda T: 0.0431*np.exp(3060./T)*0.001),
+            'specheat': (lambda T: 1.306),
+        },
+        "Salt (31 RbF, 69 RbBF4)": {
+            'density': (lambda T: -1E-08*T*T*T + 4E-05*T*T - 1.0836*T + 3242.6),
+            'viscosity': (lambda T: 0.0009),
+            'specheat': (lambda T: 9.127),
+        },
+        "Salt (46.5 LiF, 11.5 NaF, 42 KF)": {
+            'density': (lambda T: -2E-09*T*T*T + 1E-05*T*T - 0.7427*T + 2734.7),
+            'viscosity': (lambda T: 0.0400*np.exp(4170./T)*0.001),
+            'specheat': (lambda T: 2.010),
+        },
+        "Salt (49 LiF, 29 NaF, 29 ZrF4)": {
+            'density': (lambda T: -2E-11*T*T*T + 1E-07*T*T - 0.5172*T + 3674.3),
+            'viscosity': (lambda T: 0.0069),
+            'specheat': (lambda T: 1.239),
+        },
+        "Salt (58 KF, 42 ZrF4)": {
+            'density': (lambda T: -6E-10*T*T*T + 4E-06*T*T - 0.8931*T + 3661.3),
+            'viscosity': (lambda T: 0.0159*np.exp(3179./T)*0.001),
+            'specheat': (lambda T: 1.051),
+        },
+        "Salt (58 LiCl, 42 RbCl)": {
+            'density': (lambda T: -8E-10*T*T*T + 1E-06*T*T - 0.689*T + 2929.5),
+            'viscosity': (lambda T: 0.0861*np.exp(2517./T)*0.001),
+            'specheat': (lambda T: 8.918),
+        },
+        "Salt (58 NaCl, 42 MgCl2)": {
+            'density': (lambda T: -5E-09*T*T*T + 2E-05*T*T - 0.5298*T + 2444.1),
+            'viscosity': (lambda T: 0.0286*np.exp(1441./T)*0.001),
+            'specheat': (lambda T: 1.080),
+        },
+        "Salt (59.5 LiCl, 40.5 KCl)": {
+            'density': (lambda T: 1E-09*T*T*T - 5E-06*T*T - 0.864*T + 2112.6),
+            'viscosity': (lambda T: 0.0861*np.exp(2517./T)*0.001),
+            'specheat': (lambda T: 1.202),
+        },
+        "Salt (59.5 NaF, 40.5 ZrF4)": {
+            'density': (lambda T: -5E-09*T*T*T + 2E-05*T*T - 0.9144*T + 3837.),
+            'viscosity': (lambda T: 0.0767*np.exp(3977./T)*0.001),
+            'specheat': (lambda T: 1.172),
+        },
+        "Salt (60 NaNO3, 40 KNO3)": {
+            'density': (lambda T: max([-1E-07*T*T*T + 0.0002*T*T - 0.7875*T + 2299.4, 1000.0])),
+            'viscosity': (lambda T: max([-1.473302E-10*(T-273.15)**3 + 2.279989E-07*(T-273.15)**2 - 1.199514E-04*(T-273.15) + 2.270616E-02, 0.0001])),
+            'specheat': (lambda T: -1E-10*T*T*T + 2E-07*T*T + 5E-06*T + 1.4387),
+        },
+        "Nitrate Salt": {
+            'density': (lambda T: max([2090 - 0.636 * (T-273.15), 1000.0])),
+            'viscosity': (lambda T: max([(22.714 - 0.12 * (T-273.15) + 0.0002281 * (T-273.15)**2 - 0.0000001474 * (T-273.15)**3) / 1000, 1.e-6])),
+            'specheat': (lambda T: (1443. + 0.172 * (T-273.15))/1000.),
+        },
+        "Caloria HT 43": {
+            'density': (lambda T: max([885 - 0.6617 * (T-273.15) - 0.0001265 * (T-273.15)**2, 100.0])),
+            'specheat': (lambda T: (3.88 * (T-273.15) + 1606.0)/1000.),
+        },
+        "HITEC XL Nitrate Salt,": {
+            'density': (lambda T: max([2240 - 0.8266 * (T-273.15), 800.0])),
+            'viscosity': (lambda T: 1372000 * (T-273.15)**-3.364),
+            'specheat': (lambda T: max([1536 - 0.2624 * (T-273.15) - 0.0001139 * (T-273.15)**2, 1000.])/1000.),
+        },
+        "Therminol Oil": {
+            'density': (lambda T: max([1074.0 - 0.6367 * (T-273.15) - 0.0007762 * (T-273.15)**2, 400.0])),
+            'viscosity': (lambda T: 0.001 * (10**0.8703 * max(T-273.15, 20.)**(0.2877 + np.log10(max(T-273.15, 20.)**-0.3638)))),
+            'specheat': (lambda T: 1.509 + 0.002496 * (T-273.15) + 0.0000007888 * (T-273.15)**2),
+        },
+        "HITEC Salt": {
+            'density': (lambda T: max([2080 - 0.733 * (T-273.15), 1000.0])),
+            'viscosity': (lambda T: max([0.00622 - 0.0000102 * (T-273.15), 1.e-6])),
+            'specheat': (lambda T: (1560 - 0.0 * (T-273.15))/1000.),
+        },
+        "Dowtherm Q": {
+            'density': (lambda T: max([-0.757332 * (T-273.15) + 980.787, 100.0])),
+            'viscosity': (lambda T: 1 / (132.40658 + 4.36107 * (T-273.15) + 0.0781417 * (T-273.15)**2 - 0.00011035416 * (T-273.15)**3)),
+            'specheat': (lambda T: (-0.00053943 * (T-273.15)**2 + 3.2028 * (T-273.15) + 1589.2)/1000.),
+        },
+        "Dowtherm RP": {
+            'density': (lambda T: max([-0.000186495 * (T-273.15)**2 - 0.668337 * (T-273.15) + 1042.11, 200.0])),
+            'viscosity': (lambda T: 1 / (4.523003 + 0.39156855 * (T-273.15) + 0.028604206 * (T-273.15)**2)),
+            'specheat': (lambda T: (-0.0000031915 * (T-273.15)**2 + 2.977 * (T-273.15) + 1560.8)/1000.),
+        },
+        "HITEC XL": {
+            'density': (lambda T: max([2240 - 0.8266 * (T-273.15), 800.0])),
+            'viscosity': (lambda T: 1372000 * (T-273.15)**-3.364),
+            'specheat': (lambda T: max([1536 - 0.2624 * (T-273.15) - 0.0001139 * (T-273.15)**2, 1000.])/1000.),
+        },
+        "T-91 Steel": {
+            'density': (lambda T: -0.3289*(T-273.15) + 7742.5),
+            'specheat': (lambda T: 0.0004*(T-273.15)**2 + 0.2473*(T-273.15) + 450.08),
+        },
+        "Therminol 66": {
+            'density': (lambda T: -0.7146*(T-273.15) + 1024.8),
+            'viscosity': (lambda T: (1.31959963 - 0.171204729*(T-273.15) + 0.0100351594*(T-273.15)**2 - 0.000313556341*(T-273.15)**3 + 0.0000053430666*(T-273.15)**4 - 4.66597650E-08*(T-273.15)**5 + 1.63046296E-10*(T-273.15)**6) if (T-273.15) < 80. else (0.0490075884 - 0.00120478233*(T-273.15) + 0.0000130162082*(T-273.15)**2 - 7.58913847E-08*(T-273.15)**3 + 2.47856063E-10*(T-273.15)**4 - 4.26872345E-13*(T-273.15)**5 + 3.01949160E-16*(T-273.15)**6)),
+            'specheat': (lambda T: 0.0036*(T-273.15) + 1.4801),
+        },
+        "Therminol 59": {
+            'density': (lambda T: -0.0003*(T-273.15)**2 - 0.6963*(T-273.15) + 988.44),
+            'viscosity': (lambda T: (0.0137267822 - 0.000218740224*(T-273.15) + 0.0000759248815*(T-273.15)**2 - 0.00000473464744*(T-273.15)**3 - 1.97083667E-07*(T-273.15)**4 + 4.35487179E-09*(T-273.15)**5 + 2.40243056E-10*(T-273.15)**6) if (T-273.15) < 25. else (0.0114608807 - 0.000313431056*(T-273.15) + 0.00000416778121*(T-273.15)**2 - 3.04668508E-08*(T-273.15)**3 + 1.23719006E-10*(T-273.15)**4 - 2.60834697E-13*(T-273.15)**5 + 2.22227675E-16*(T-273.15)**6)),
+            'specheat': (lambda T: 0.0033*(T-273.15) + 1.6132),
+        },
+        "Argon": {
+            'density': (lambda T, P: max([P/(208.13*T), 1.e-10])),
+            'viscosity': (lambda T: 4.4997e-6 + 6.38920E-08*T - 1.24550E-11*T*T),
+            'specheat': (lambda T: 0.5203),
+        },
+        "Hydrogen": {
+            'density': (lambda T, P: max([P/(4124.*T), 1.e-10])),
+            'viscosity': (lambda T: 0.00000231 + 2.37842E-08*T - 5.73624E-12*T*T),
+            'specheat': (lambda T: min([max([-45.4022 + 0.690156*T - 0.00327354*T*T + 0.00000817326*T**3 - 1.13234E-08*T**4 + 8.24995E-12*T**5 - 2.46804E-15*T**6, 11.3]), 14.7])),
+        },
+        "Dowtherm A": {
+            # Density polynomial fit to Dow Chemical published data (kg/m³), T in K.
+            # Fitted to: T_C=15→1061, 50→1031, 100→985, 150→936, 200→884, 250→830, 300→772, 350→712 kg/m³
+            'density': (lambda T: max([1071.0 - 0.803*(T-273.15) - 0.000644*(T-273.15)**2, 100.0])),
+            'viscosity': (lambda T: 0.786512*max(T-273.15, 20.)**-1.44263),
+            'specheat': (lambda T: 1.47524 + 0.00368606*((T-273.15)-273) - 0.00000516458*((T-273.15)-273)**2 + 8.99399E-09*((T-273.15)-273)**3),
+        },
+    }
+
+    def enthalpy(self, fluid: str, T: float, T_ref: float = 273.15, P: float = float('nan')):
+        """Calculate specific enthalpy [J/kg] from temperature T [K] relative to T_ref [K] (default 0°C).
+        Computed by integrating specific heat [J/(kg·K)] from T_ref to T.
+        Only enthalpy differences are physically meaningful; the reference temperature cancels in all
+        energy balance applications."""
+        from scipy.integrate import quad
+        assert fluid in self.funcmap.keys(), f"Fluid '{fluid}' not found in database"
+        assert 'specheat' in self.funcmap[fluid], f"No specific heat data available for '{fluid}'"
+        cp_func = self.funcmap[fluid]['specheat']
+        h_kJ_per_kg, _ = quad(cp_func, T_ref, T)
+        return h_kJ_per_kg  # Convert kJ/kg → J/kg
+
+    def density(self, fluid: str, T: float, P: float = float('nan')):
+        """Calculate density [kg/m^3] from temperature [K] and optional pressure [Pa].
+        Argon and Hydrogen require pressure."""
+        assert fluid in self.funcmap.keys(), f"Fluid '{fluid}' not found in database"
+        assert 'density' in self.funcmap[fluid], f"No density data available for '{fluid}'"
+        
+        if fluid in ['Argon', 'Hydrogen']:
+            assert P == P, "Pressure required for Argon and Hydrogen"
+            return self.funcmap[fluid]['density'](T, P)
+        else:
+            return self.funcmap[fluid]['density'](T)
+
+    def viscosity(self, fluid: str, T: float, P: float = float('nan')):
+        """Calculate dynamic viscosity [Pa-s] from temperature [K] and optional pressure [Pa]."""
+        assert fluid in self.funcmap.keys(), f"Fluid '{fluid}' not found in database"
+        assert 'viscosity' in self.funcmap[fluid], f"No viscosity data available for '{fluid}'"
+        return self.funcmap[fluid]['viscosity'](T)
+
+    def specheat(self, fluid: str, T: float, P: float = float('nan')):
+        """Calculate specific heat [J/kg-K] from temperature [K] and optional pressure [Pa]."""
+        assert fluid in self.funcmap.keys(), f"Fluid '{fluid}' not found in database"
+        assert 'specheat' in self.funcmap[fluid], f"No specific heat data available for '{fluid}'"
+        return self.funcmap[fluid]['specheat'](T) * 1000. # Convert kJ/kg-K → J/kg-K
+    
+    def print_fluids(self):
+        """Print list of fluids in database"""
+        for fluid in self.funcmap.keys():
+            available_properties = self.funcmap[fluid].keys()
+            abbrev_properties = {'density': 'ρ', 'viscosity': 'μ', 'specheat': 'c'}
+            abbrev_available = [abbrev_properties[prop] for prop in available_properties]
+            print(fluid + " → (" + ", ".join(abbrev_available) + ")")
+
+if __name__ == "__main__":
+    props = Incompressible()
+    props.print_fluids()

esclab/components/template_component.py

@@ -0,0 +1,120 @@
+"""
+This file serves as a template for a Component library.
+
+The file is stuctured to include definitions for multiple Components.
+
+To make this library available to esclab, add the following line to src/esclab/components/__init__.py:
+from .template_component import *
+"""
+
+# import necessary simulation tools
+from esclab.simulate import *
+
+
+# ---------------------------------------------------------
+# Define component classes. Each component is a class that inherits from Component, and defines its own parameters, inputs, outputs, and calculate() method.
+
+
+class FirstComponent(Component):
+    """Template component - a simple calculator"""
+    # Parameters. 
+    #   Any parameter not given a default value must be set by the user before running the simulation.
+    a = Component.Parameter()  # multiplier
+    b = Component.Parameter()  # offset
+    # Inputs. 
+    #   The default input initial value is 1, but this can be passed as an argument here, or changed by directly setting the input value to a different number before running the simulation.
+    x_in = Component.Input()  # input variable
+    # Outputs. 
+    #   The output value will be whatever is assigned in calculate().
+    y_out = Component.Output()  # output variable
+    z_out = Component.Output()  # another output variable
+
+    def __init__(self):
+        # [optional] 
+        # initialize any internal variables here. Items stored as attributes of self will persist across time steps and iterations, and can be used to store intermediate values or state information. 
+        super().__init__()  # call the parent class constructor [required if you define __init__()]
+        self.x_last = 0.  # example of an internal variable to store the value of the input from the last time step  
+
+    def presim_setup(self, **kwargs):
+        super().presim_setup(**kwargs)
+        # [optional] do any setup before the simulation starts here. This method is called once after the model is initialized, and before the first time step. You can use this to set up any internal variables or perform any calculations that are needed before the simulation starts. This differs from __init__ in that the model and all components are guaranteed to be fully initialized at this point, so you can access other components and their parameters and outputs if needed.
+        return
+
+    def calculate(self):
+        # [required] define the equations that govern the behavior of the component here. This method is called at every time step and iteration.
+
+        # super().calculate()  # << call this if inheriting from a parent class that also uses calculate(). Not needed otherwise.
+
+        # ---------------------------------------
+        # Do any first timestep calculations
+        if self.is_first_timestep:
+            # do any calculations that are needed at the first time step here. For example, you might 
+            # want to set the output to a specific value at the first time step, or calculate an initial 
+            # condition based on the input value at the first time step. 
+            # return  # << uncomment to skip the rest of the calculations for the first time step
+            pass  # continue out of this block if regular calculations are needed at the first time step
+
+        # ---------------------------------------
+        # Do post-convergence calculations 
+        if self.is_converged:
+            # do any calculations that are needed after convergence at each step(). For example, you 
+            # might want to update the output based on the input and parameters after convergence is 
+            # reached, or calculate some additional outputs that are only needed after convergence. 
+            self.x_last = self.x_in  # store the input value for use in the next time step
+            return  # skip the rest of the calculations if needed
+        
+        
+        
+        # ---------------------------------------
+        # Do regular calculations for each iteration here. This is where the main behavior of the component
+        # should be defined. For example, you might want to define the output as a function of the input 
+        # and parameters here.
+
+        self.y_out = self.a * self.x_in + self.b  # example calculation for y_out
+        self.z_out = self.x_in - self.x_last  # example calculation for z_out
+        
+
+        # ---------------------------------------
+        # If using the simultaneous equation solving feature, add equations to self.coupled_eqs here instead 
+        # of directly calculating the outputs. This allows the equations to be solved simultaneously with 
+        # other components in the same solve group. For example:
+        if self.coupled_eqs is not None:  # check if we are in the matrix-build phase
+            # Note that we use self.coupled_eqs.source(self.x_in) to refer to the input variable in the 
+            # equation, which allows the solver to correctly link it to the output of whatever component 
+            # is connected to this input. Point to the output variable directly (self.y_out) since it is 
+            # an output of this component.
+
+            # add an equation for y_out: y_out = a * x_in + b  -->  y_out - a*x_in = b
+            self.coupled_eqs.add_equation({
+                self.y_out: 1.0,
+                self.coupled_eqs.source(self.x_in): -1.0,
+            }, rhs=self.b)
+            #  add an equation for z_out: z_out = x_in - x_last  -->  z_out - x_in = -x_last
+            self.coupled_eqs.add_equation({
+                self.z_out: 1.0,
+                self.coupled_eqs.source(self.x_in): -1.0,
+            }, rhs=-self.x_last)
+
+            # The syntax of the add_equation() method is as follows:
+            #     {var1: coeff1,      | dictionary of variables and their 
+            #      var2: coeff2,      | coefficients in the equation
+            #      ...},              | 
+
+            #     rhs=value           | right-hand side value of the equation 
+            #                         | (any constants that are not multiplied 
+            #                         | by a variable should be included here)
+# ----------------------------------------------------------
+
+# ----------------------------------------------------------
+class SecondComponent(Component):
+    """Another example component. This one doesn't do anything, but serves as an example of how to define multiple components in the same file."""
+    x_in = Component.Input()
+    y_out = Component.Output()
+    def calculate(self):
+        if self.coupled_eqs is not None:  # check if we are in the matrix-build phase
+            # add an equation for y_out: y_out = x_in  -->  y_out - x_in = 0
+            self.coupled_eqs.add_equation({
+                self.y_out: 1.0,
+                self.coupled_eqs.source(self.x_in): -1.0,
+            }, rhs=0.0)
+# ----------------------------------------------------------

esclab/models/__init__.py

@@ -0,0 +1 @@
+# This file marks the models directory as a Python package.