processpi 0.0.0__py3-none-any.whl

processpi/calculations/reaction_engineering/reaction_rate.py

@@ -0,0 +1,143 @@
+# processpi/calculations/reaction_engineering/reaction_rate.py
+
+from typing import Dict, Optional, Mapping
+from ..base import CalculationBase
+
+
+class ReactionRate(CalculationBase):
+    """
+    General reaction-rate calculator supporting several kinetic models.
+
+    Workflows (select with `model`):
+    --------------------------------
+    1) Power law (elementary / empirical):
+        model = "power_law"
+        Inputs:
+            C: Mapping[str, float]         # species concentrations, mol/L (or consistent units)
+            exponents: Mapping[str, float] # reaction orders for each species (e.g., {"A":1, "B":1})
+            k: float                       # rate constant (units consistent with orders & C)
+            (optional) A, Ea, T, R         # If k not given, compute k via Arrhenius: k = A*exp(-Ea/(R*T))
+        Output: {"rate": float}
+
+        Equation:
+            r = k * Π_i C_i^{a_i}
+
+    2) Langmuir–Hinshelwood (adsorption + surface reaction):
+        model = "langmuir_hinshelwood"
+        Inputs:
+            k or (A, Ea, T, R)             # rate constant or Arrhenius params
+            C: Mapping[str, float]         # species concentrations (e.g., {"A":..., "B":...})
+            K: Mapping[str, float]         # adsorption constants for species present
+            numerator: Mapping[str, float] # stoich exponents in numerator (default {"A":1})
+            denom_power: float = 1.0       # overall power on denominator (default 1)
+        Output: {"rate": float}
+
+        Equation (generic):
+            r = k * Π_j (C_j)^{ν_j} / [ 1 + Σ_i K_i C_i ]^{denom_power}
+
+    3) Michaelis–Menten (enzymatic form, optional):
+        model = "michaelis_menten"
+        Inputs:
+            Vmax: float
+            Km: float
+            S: float                        # substrate concentration
+        Output: {"rate": float}
+
+        Equation:
+            r = Vmax * S / (Km + S)
+
+    Notes
+    -----
+    * Units are your responsibility; keep them consistent.
+    * If both `k` and (A,Ea,T[,R]) are provided, `k` is used and Arrhenius params ignored.
+    * Default R = 8.314 if not supplied and Arrhenius is used.
+    """
+
+    def validate_inputs(self):
+        model = self.inputs.get("model", "power_law").lower()
+        if model not in ("power_law", "langmuir_hinshelwood", "michaelis_menten"):
+            raise ValueError("model must be 'power_law', 'langmuir_hinshelwood', or 'michaelis_menten'.")
+
+        if model == "power_law":
+            if "C" not in self.inputs or "exponents" not in self.inputs:
+                raise ValueError("power_law requires 'C' and 'exponents'.")
+            C = self.inputs["C"]
+            exps = self.inputs["exponents"]
+            if not isinstance(C, Mapping) or not isinstance(exps, Mapping):
+                raise ValueError("'C' and 'exponents' must be mappings.")
+            # Either k or Arrhenius parameters:
+            if "k" not in self.inputs and not all(k in self.inputs for k in ("A", "Ea", "T")):
+                raise ValueError("Provide 'k' or Arrhenius params (A, Ea, T) for power_law.")
+
+        elif model == "langmuir_hinshelwood":
+            for key in ("C", "K"):
+                if key not in self.inputs:
+                    raise ValueError(f"langmuir_hinshelwood requires '{key}'.")
+            if "k" not in self.inputs and not all(k in self.inputs for k in ("A", "Ea", "T")):
+                raise ValueError("Provide 'k' or Arrhenius params (A, Ea, T) for langmuir_hinshelwood.")
+
+        elif model == "michaelis_menten":
+            for key in ("Vmax", "Km", "S"):
+                if key not in self.inputs:
+                    raise ValueError(f"michaelis_menten requires '{key}'.")
+
+    def _arrhenius_k(self) -> float:
+        """Compute k via Arrhenius if A, Ea, T present. Default R=8.314 unless provided."""
+        if all(k in self.inputs for k in ("A", "Ea", "T")):
+            import math
+            A = float(self.inputs["A"])
+            Ea = float(self.inputs["Ea"])
+            T = float(self.inputs["T"])
+            R = float(self.inputs.get("R", 8.314))
+            return A * math.exp(-Ea / (R * T))
+        raise ValueError("Arrhenius parameters (A, Ea, T) are required to compute k.")
+
+    def calculate(self) -> Dict:
+        model = self.inputs.get("model", "power_law").lower()
+
+        if model == "power_law":
+            C: Mapping[str, float] = self.inputs["C"]
+            exps: Mapping[str, float] = self.inputs["exponents"]
+            k = float(self.inputs.get("k", self._arrhenius_k()))
+            rate = k
+            for sp, a in exps.items():
+                c = float(C.get(sp, 0.0))
+                if c < 0:
+                    raise ValueError(f"Negative concentration for species '{sp}'.")
+                rate *= c ** float(a)
+            return {"rate": rate}
+
+        if model == "langmuir_hinshelwood":
+            C: Mapping[str, float] = self.inputs["C"]
+            K: Mapping[str, float] = self.inputs["K"]
+            k = float(self.inputs.get("k", self._arrhenius_k()))
+            numerator = self.inputs.get("numerator", {"A": 1.0})
+            denom_power = float(self.inputs.get("denom_power", 1.0))
+
+            # numerator term
+            num = k
+            for sp, nu in numerator.items():
+                c = float(C.get(sp, 0.0))
+                if c < 0:
+                    raise ValueError(f"Negative concentration for species '{sp}'.")
+                num *= c ** float(nu)
+
+            # denominator term (1 + Σ K_i C_i)^{denom_power}
+            denom_sum = 1.0
+            for sp, Ki in K.items():
+                c = float(C.get(sp, 0.0))
+                if c < 0:
+                    raise ValueError(f"Negative concentration for species '{sp}'.")
+                denom_sum += float(Ki) * c
+
+            rate = num / (denom_sum ** denom_power)
+            return {"rate": rate}
+
+        # michaelis_menten
+        Vmax = float(self.inputs["Vmax"])
+        Km = float(self.inputs["Km"])
+        S = float(self.inputs["S"])
+        if Vmax < 0 or Km < 0 or S < 0:
+            raise ValueError("Vmax, Km, and S must be non-negative.")
+        rate = Vmax * S / (Km + S) if (Km + S) > 0 else 0.0
+        return {"rate": rate}

processpi/calculations/reaction_engineering/residence_time.py

@@ -0,0 +1,80 @@
+# processpi/calculations/reaction_engineering/residence_time.py
+
+from typing import Dict, Literal
+from ..base import CalculationBase
+
+
+class ResidenceTime(CalculationBase):
+    """
+    Space time (τ) and conversion relations for ideal reactors.
+
+    Workflows (select with `mode`):
+    -------------------------------
+    1) Space time:
+        mode = "tau"
+        Inputs:
+            V: float            # reactor volume
+            Q: float            # volumetric flow rate
+        Output:
+            {"tau": float, "space_velocity": float}
+        Equations:
+            τ = V / Q
+            SV = 1 / τ
+
+    2) Conversion for first-order kinetics (isothermal, constant density):
+        mode = "conversion"
+        Inputs:
+            reactor: "CSTR" or "PFR"
+            k: float            # first-order rate constant (1/time)
+            tau: float          # space time (V/Q)
+        Output:
+            {"X": float}
+        Equations:
+            CSTR:   X = (k τ) / (1 + k τ)
+            PFR:    X = 1 - exp(-k τ)
+    """
+
+    def validate_inputs(self):
+        mode = self.inputs.get("mode", "tau").lower()
+        if mode not in ("tau", "conversion"):
+            raise ValueError("mode must be 'tau' or 'conversion'.")
+
+        if mode == "tau":
+            for k in ("V", "Q"):
+                if k not in self.inputs:
+                    raise ValueError(f"Missing required input: {k}")
+            if float(self.inputs["V"]) <= 0 or float(self.inputs["Q"]) <= 0:
+                raise ValueError("V and Q must be > 0.")
+
+        else:  # conversion
+            for k in ("reactor", "k", "tau"):
+                if k not in self.inputs:
+                    raise ValueError(f"Missing required input: {k}")
+            reactor = str(self.inputs["reactor"]).upper()
+            if reactor not in ("CSTR", "PFR"):
+                raise ValueError("reactor must be 'CSTR' or 'PFR'.")
+            if float(self.inputs["k"]) < 0 or float(self.inputs["tau"]) < 0:
+                raise ValueError("k and tau must be >= 0.")
+
+    def calculate(self) -> Dict:
+        mode = self.inputs.get("mode", "tau").lower()
+
+        if mode == "tau":
+            V = float(self.inputs["V"])
+            Q = float(self.inputs["Q"])
+            tau = V / Q
+            SV = 1.0 / tau
+            return {"tau": tau, "space_velocity": SV}
+
+        # conversion
+        import math
+        reactor = str(self.inputs["reactor"]).upper()
+        k = float(self.inputs["k"])
+        tau = float(self.inputs["tau"])
+
+        if reactor == "CSTR":
+            X = (k * tau) / (1.0 + k * tau) if (1.0 + k * tau) > 0 else 0.0
+        else:  # PFR
+            X = 1.0 - math.exp(-k * tau)
+
+        return {"X": X}

processpi/calculations/thermodynamics/__init__.py

@@ -0,0 +1,4 @@
+from .enthalpy_change import EnthalpyChange
+from .entropy_change import EntropyChange
+from .heat_of_vaporization import HeatOfVaporization
+__all__ = ["EnthalpyChange", "EntropyChange", "HeatOfVaporization"]

processpi/calculations/thermodynamics/enthalpy_change.py

@@ -0,0 +1,23 @@
+from ..base import CalculationBase
+from ...units import *
+
+class EnthalpyChange(CalculationBase):
+    """
+    Calculate enthalpy change using:
+        ΔH = m * Cp * ΔT
+    """
+
+    def validate_inputs(self):
+        required = ["mass", "specific_heat", "temp_initial", "temp_final"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        m = self._get_value(self.inputs["mass"], "mass")                     # kg
+        Cp = self._get_value(self.inputs["specific_heat"], "specific_heat")  # J/kg·K
+        T1 = self._get_value(self.inputs["temp_initial"], "temp_initial")    # °C or K
+        T2 = self._get_value(self.inputs["temp_final"], "temp_final")        # °C or K
+
+        ΔH = m * Cp * (T2 - T1)
+        return EnthalpyChange(ΔH, "J")

processpi/calculations/thermodynamics/entropy_change.py

@@ -0,0 +1,25 @@
+from processpi.calculations.base import CalculationBase
+import math
+
+class EntropyChange(CalculationBase):
+    """
+    Calculate entropy change (ideal reversible process):
+        ΔS = m * Cp * ln(T2/T1)
+    """
+
+    def validate_inputs(self):
+        required = ["mass", "specific_heat", "temp_initial", "temp_final"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+        if self.inputs["temp_initial"] <= 0 or self.inputs["temp_final"] <= 0:
+            raise ValueError("Temperatures must be > 0 K for entropy calculation")
+
+    def calculate(self):
+        m = self._get_value(self.inputs["mass"], "mass")                     # kg
+        Cp = self._get_value(self.inputs["specific_heat"], "specific_heat")  # J/kg·K
+        T1 = self._get_value(self.inputs["temp_initial"], "temp_initial")    # K
+        T2 = self._get_value(self.inputs["temp_final"], "temp_final")        # K
+
+        ΔS = m * Cp * math.log(T2 / T1)
+        return {"entropy_change_J_per_K": ΔS}

processpi/calculations/thermodynamics/heat_of_vaporization.py

@@ -0,0 +1,20 @@
+from processpi.calculations.base import CalculationBase
+
+class HeatOfVaporization(CalculationBase):
+    """
+    Calculate heat required for vaporization:
+        Q = m * ΔHvap
+    """
+
+    def validate_inputs(self):
+        required = ["mass", "heat_vaporization"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        m = self._get_value(self.inputs["mass"], "mass")                             # kg
+        ΔHvap = self._get_value(self.inputs["heat_vaporization"], "heat_vaporization")  # J/kg
+
+        Q = m * ΔHvap
+        return {"heat_required_J": Q}

processpi/components/__init__.py

@@ -0,0 +1,5 @@
+from .water import Water
+from .base import Component     
+
+__all__ = ["Water", 
+           "Component"]

processpi/components/aceticacid.py

@@ -0,0 +1,19 @@
+from .base import Component
+from processpi.units import *
+
+
+class AceticAcid(Component):
+    name = "Acetic Acid"
+    formula = "CH3COOH"
+    molecular_weight = 60.052
+    _critical_temperature = Temperature(591.95, "K")
+    _critical_pressure = Pressure(5.786, "MPa") 
+    _critical_volume = Volume(0.177, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.208  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.4665  # Placeholder for critical acentric factor
+    _density_constants = [1.4486, 0.25892, 591.95, 0.2529]
+    _specific_heat_constants = [139640,-320.8,0.8985,0,0]
+    _viscosity_constants = [-9.03, 1212.3, -0.322, 0, 0] 
+    _thermal_conductivity_constants = [0.214, -0.0001834, 0,0,0]
+    _vapor_pressure_constants = [53.27, -6304.5, -4.2985, 8.8865E-18, 6] 
+    _enthalpy_constants = [4.0179E-7, 2.6037, -5.0031,2.7069, 0]  # Placeholder for enthalpy constants

processpi/components/acetone.py

@@ -0,0 +1,20 @@
+
+from .base import Component
+from processpi.units import *
+
+
+class Acetone(Component):
+    name = "Acetone"
+    formula = "C3H6O"
+    molecular_weight = 58.080
+    _critical_temperature = Temperature(508.1, "K")
+    _critical_pressure = Pressure(4.701, "MPa")
+    _critical_volume = Volume(0.209, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.233  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.3065  # Placeholder for critical acentric factor
+    _density_constants = [1.2332, 0.25886, 508.2, 0.2913]
+    _specific_heat_constants = [135600,-177,0.2837,0.000689,0]
+    _viscosity_constants = [-14.918, 1023.4, 0.5961, 0, 0] 
+    _thermal_conductivity_constants = [0.2878, -0.000427, 0,0,0]
+    _vapor_pressure_constants = [69.006, -5599.6, -7.0985, 0.0000062237, 2] 
+    _enthalpy_constants = [4.215E-7, 0.3397, 178.45, 3.639, 0]  # Placeholder for enthalpy constants

processpi/components/acrylicacid.py

@@ -0,0 +1,19 @@
+from .base import Component
+from processpi.units import *
+
+
+class AcrylicAcid(Component):
+    name = "Acrylic Acid"
+    formula = "C3​H4​O2​"
+    molecular_weight = 72.063
+    _critical_temperature = Temperature(615, "K")
+    _critical_pressure = Pressure(5.66, "MPa") 
+    _critical_volume = Volume(0.208, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.23  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.5383  # Placeholder for critical acentric factor
+    _density_constants = [1.2414, 0.25822, 615,0.30701]
+    _specific_heat_constants = [55300,300,0,0,0]
+    _viscosity_constants = [-28.12, 2280.2, 2.3956, 0, 0] 
+    _thermal_conductivity_constants = [0.2441, -0.0002904, 0,0,0]
+    _vapor_pressure_constants = [46.745, -6587.1, -3.2208, 0.00000052253, 2] 
+    _enthalpy_constants = [4.3756E-7, 2.2571,-4.5116,2.5738, 0]  # Placeholder for enthalpy constants

processpi/components/air.py

@@ -0,0 +1,20 @@
+
+from .base import Component
+from processpi.units import *
+
+
+class Air(Component):
+    name = "Air"
+    formula = "Mixture​"
+    molecular_weight = 28.96
+    _critical_temperature = Temperature(132.45, "K")
+    _critical_pressure = Pressure(3.774, "MPa") 
+    _critical_volume = Volume(0.09147, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.313  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0  # Placeholder for critical acentric factor
+    _density_constants = [0.26733, 132.45, 0.27341,59.15]
+    _specific_heat_constants = [-214460,9185.1,-106.12,0.41616,0]
+    _viscosity_constants = [-20.077, 285.15, 1.784,-6.2382E-22, 10] 
+    _thermal_conductivity_constants = [0.28472, -0.0017393, 0,0,0]
+    _vapor_pressure_constants = [21.662, -692.39, -0.392, 0.0047574, 1] 
+    _enthalpy_constants = [0.3822E-7, 59.15,0.6759,132.45, 0]  # Placeholder for enthalpy constants

processpi/components/ammonia.py

@@ -0,0 +1,19 @@
+from .base import Component
+from processpi.units import *
+
+
+class Ammonia(Component):
+    name = "Ammonia"
+    formula = "NH3"
+    molecular_weight = 17.031
+    _critical_temperature = Temperature(405.65, "K")
+    _critical_pressure = Pressure(11.28, "MPa") 
+    _critical_volume = Volume(0.07247, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.242  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.2526  # Placeholder for critical acentric factor
+    _density_constants = [3.5383, 0.25443, 405.65, 0.2888]
+    _specific_heat_constants = [61.289,80925,799.4,-2651,0]
+    _viscosity_constants = [-6.743,598.3,-0.7341,-3.69E-27, 10] 
+    _thermal_conductivity_constants = [1.169, -0.002314, 0,0,0]
+    _vapor_pressure_constants = [90.483, -4,669.70, -11.607, 1.72E-02, 1] 
+    _enthalpy_constants = [3.1523E-7, 0.3914, -0.2289,0.2309, 0]  # Placeholder for enthalpy constants

processpi/components/base.py

@@ -0,0 +1,85 @@
+from abc import ABC, abstractmethod
+from processpi.units import *
+from math import exp, log
+
+class Component(ABC):
+    """
+    Base class for a chemical component.
+    Each subclass must define its own physical and chemical properties.
+    """
+
+    def __init__(self, temperature: Temperature = None, pressure: Pressure = None):
+        self.temperature = temperature or Temperature(35, "C")
+        self.pressure = pressure or Pressure(101325, "Pa")
+
+    @property
+    @abstractmethod
+    def name(self):
+        pass
+
+    @property
+    @abstractmethod
+    def formula(self):
+        pass
+
+    @property
+    @abstractmethod
+    def molecular_weight(self):
+        pass
+
+    # Generic density method (can be overridden in subclasses)
+    def density(self, temperature: Temperature = None) -> Density:
+        temperature = self._get_temperature(temperature)
+        T = temperature.value
+        den = self._density_constants[0] / (self._density_constants[1] ** (1 + (1 - (T/self._density_constants[2])**self._density_constants[3])))
+        den = den * self.molecular_weight
+        return Density(den, "kg/m3")
+
+    def _get_temperature(self, temperature: Temperature):
+        return temperature or self.temperature
+
+    def specific_heat(self, temperature: Temperature = None):
+        temperature = self._get_temperature(temperature)
+        T = temperature.value
+        cp = (self._specific_heat_constants[0] +
+              self._specific_heat_constants[1] * T +
+              self._specific_heat_constants[2] * T**2 +
+              self._specific_heat_constants[3] * T**3 +
+              self._specific_heat_constants[4] * T**4)
+        cp = cp * self.molecular_weight
+        return SpecificHeat(cp, "J/kgK")
+
+    def viscosity(self, temperature: Temperature = None):
+        temperature = self._get_temperature(temperature)
+        T = temperature.value
+        po = self._viscosity_constants[0] + (self._viscosity_constants[1] / T) + (self._viscosity_constants[2] * log(T)) + (self._viscosity_constants[3] * (T**self._viscosity_constants[4]))
+        vis = exp(po)
+        return Viscosity(vis, "Pa·s")
+
+    def thermal_conductivity(self, temperature: Temperature = None):
+        temperature = self._get_temperature(temperature)
+        T = temperature.value
+        k = (self._thermal_conductivity_constants[0] +
+             self._thermal_conductivity_constants[1] * T +
+             self._thermal_conductivity_constants[2] * T**2 +
+             self._thermal_conductivity_constants[3] * T**3 +
+             self._thermal_conductivity_constants[4] * T**4)
+        return ThermalConductivity(k, "W/mK")
+
+    def vapor_pressure(self, temperature: Temperature = None):
+        temperature = self._get_temperature(temperature)
+        T = temperature.value
+        po = (self._vapor_pressure_constants[0] + (self._vapor_pressure_constants[1] / T) +
+              (self._vapor_pressure_constants[2] * log(T)) +
+              (self._vapor_pressure_constants[3] * (T**self._vapor_pressure_constants[4])))
+        vp = exp(po)
+        return Pressure(vp, "Pa")
+
+    def enthalpy(self, temperature: Temperature = None):
+        temperature = self._get_temperature(temperature)
+        T = temperature.value
+        Tr = T / self._critical_temperature.value
+        tou = 1 - Tr
+        dH =  self._enthalpy_constants[0] * (tou**((self._enthalpy_constants[1]) + (self._enthalpy_constants[2] * tou) + (self._enthalpy_constants[3] * (tou**2)) + (self._enthalpy_constants[4] * (tou**3))))
+        dH = dH * self.molecular_weight
+        return HeatOfVaporization(dH, "J/kg")

processpi/components/benzene.py

@@ -0,0 +1,40 @@
+
+from .base import Component
+from processpi.units import *
+
+
+class Benzene(Component):
+    name = "Benzene"
+    formula = "C6H6"
+    molecular_weight = 78.114
+    _critical_temperature = Temperature(562.1, "K")
+    _critical_pressure = Pressure(4.895, "MPa")
+    _critical_volume = Volume(0.256, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.268  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.2103  # Placeholder for critical acentric factor
+    _density_constants = [1.0259, 0.26666, 562.05, 0.28394]
+    _specific_heat_constants_1 = [129440,-169.5,0.64781,0,0]
+    _specific_heat_constants_2 = [162940,-344.94,0.85562,0,0]
+    _viscosity_constants = [7.5117, 294.68,-2.794, 0, 0] 
+    _thermal_conductivity_constants = [0.23444, -0.00030572, 0,0,0]
+    _vapor_pressure_constants = [83.107, -6486.2, -9.2194, 0.0000069844, 2] 
+    _enthalpy_constants = [4.5346E-7, 0.39053, 278.68, 3.4705, 0]  # Placeholder for enthalpy constants
+    def specific_heat(self, temperature: Temperature):
+        """Return specific heat in kJ/kg.K as a function of temperature in °C"""
+        Tr = temperature.value / self._critical_temperature.value
+        T = temperature.value
+        # Using a polynomial fit for specific heat as a function of reduced temperature
+        if T <= 353.24:
+            constants = self._specific_heat_constants_1
+        else:
+            constants = self._specific_heat_constants_2
+        
+        cp = (constants[0] +
+              constants[1] * T +
+              constants[2] * T**2 +
+              constants[3] * T**3 +
+              constants[4] * T**4)
+        # Convert to kJ/kg.K
+        #cp /= 1000.0
+        cp = cp * self.molecular_weight
+        return SpecificHeat(cp, "J/kgK")

processpi/components/benzoicacid.py

@@ -0,0 +1,19 @@
+from .base import Component
+from processpi.units import *
+
+
+class BenzoicAcid(Component):
+    name = "Benzoic Acid"
+    formula = "C7H6O"
+    molecular_weight = 122.121
+    _critical_temperature = Temperature(751, "K")
+    _critical_pressure = Pressure(4.47, "MPa") 
+    _critical_volume = Volume(0.344, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.246  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.6028  # Placeholder for critical acentric factor
+    _density_constants = [0.71587, 0.24812, 751,0.2857]
+    _specific_heat_constants = [-5480,647.12,0,0,0]
+    _viscosity_constants = [-12.947,2557.9,0,0, 0] 
+    _thermal_conductivity_constants = [0.2391, -0.0002325, 0,0,0]
+    _vapor_pressure_constants = [88.513, -11829, -8.6826, 2.32E-19, 6] 
+    _enthalpy_constants = [10.19E-7, 0.478, 395.45,7.1277, 0]  # Placeholder for enthalpy constants

processpi/components/bromine.py

@@ -0,0 +1,19 @@
+from .base import Component
+from processpi.units import *
+
+
+class Bromine(Component):
+    name = "Bromine"
+    formula = "Br2"
+    molecular_weight = 159.808
+    _critical_temperature = Temperature(584.15, "K")
+    _critical_pressure = Pressure(10.3, "MPa") 
+    _critical_volume = Volume(0.135, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.286  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.129  # Placeholder for critical acentric factor
+    _density_constants = [2.1872, 0.29527, 584.15,0.3295]
+    _specific_heat_constants = [179400,-667.11,1.0701,0,0]
+    _viscosity_constants = [16.775,-314,-3.9763,0, 0] 
+    _thermal_conductivity_constants = [-0.2185, 0.0042143,-0.000017753,3.10E-08,-2.01E-11]
+    _vapor_pressure_constants = [108.26, -6592, -14.16,1.60E-02, 1] 
+    _enthalpy_constants = [4E-7, 0.351, 265.85,3.2323, 0]  # Placeholder for enthalpy constants

processpi/components/butane.py

@@ -0,0 +1,19 @@
+from .base import Component
+from processpi.units import *
+
+
+class Butane(Component):
+    name = "Butane"
+    formula = "C4H10"
+    molecular_weight = 58.122
+    _critical_temperature = Temperature(425.12, "K")
+    _critical_pressure = Pressure(3.796, "MPa") 
+    _critical_volume = Volume(0.255, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.274  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.2002  # Placeholder for critical acentric factor
+    _density_constants = [1.0677, 0.27188,425.12,0.28688]
+    _specific_heat_constants = [191030,-1675,12.5,-0.03874,4.61E-05]
+    _viscosity_constants = [-7.2471,534.82,-0.57469,-4.66E-27, 0] 
+    _thermal_conductivity_constants = [0.27349, -0.00071267,5.16E-07,0,0]
+    _vapor_pressure_constants = [66.343,-4363.20,-7.046,9.45E-06, 2] 
+    _enthalpy_constants = [3.6238E-7, 0.8337, -0.82274,0.39613, 0]  # Placeholder for enthalpy constants

processpi/components/carbondioxide.py

@@ -0,0 +1,19 @@
+from .base import Component
+from processpi.units import *
+
+
+class Carbondioxide(Component):
+    name = "Carbon Dioxide"
+    formula = "CO2"
+    molecular_weight = 44.01
+    _critical_temperature = Temperature(304.21, "K")
+    _critical_pressure = Pressure(7.383, "MPa") 
+    _critical_volume = Volume(0.094, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.274  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.2236  # Placeholder for critical acentric factor
+    _density_constants = [2.768, 0.26212,304.21,0.2908]
+    _specific_heat_constants = [-8304300,104370,-433.33,0.60052,0]
+    _viscosity_constants = [18.775,-402.92,-4.6854,-6.92E-26, 10] 
+    _thermal_conductivity_constants = [0.4406, -0.0012175,0,0,0]
+    _vapor_pressure_constants = [140.54,-4735,-21.268,4.09E-02, 1] 
+    _enthalpy_constants = [2.173E-7, 0.382, -0.4339,0.42213, 0]  # Placeholder for enthalpy constants

processpi/components/carbonmonoxide.py

@@ -0,0 +1,17 @@
+from .base import Component
+from processpi.units import *
+class CarbonMonoxide(Component):
+    name = "Carbon Monoxide"
+    formula = "CO"
+    molecular_weight = 28.01
+    _critical_temperature = Temperature(132.92, "K")
+    _critical_pressure = Pressure(3.499, "MPa") 
+    _critical_volume = Volume(0.0944, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.299  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.0482  # Placeholder for critical acentric factor
+    _density_constants = [2.897, 0.27532,132.92,0.2813]
+    _specific_heat_constants = [65.429,28723,-847.39,1,959.60,0]
+    _viscosity_constants = [-4.9735,97.67,-1.1088,0, 0] 
+    _thermal_conductivity_constants = [0.2855, -0.001784,0,0,0]
+    _vapor_pressure_constants = [45.698,-1076.60,-4.8814,7.57E-05, 2] 
+    _enthalpy_constants = [0.8585E-7, 0.4921, -0.326,0.2231, 0]  # Placeholder for enthalpy constants

processpi/components/carbontetrachloride.py

@@ -0,0 +1,17 @@
+from .base import Component
+from processpi.units import *
+class CarbonTetrachloride(Component):
+    name = "Carbon Tetrachloride"
+    formula = "CO"
+    molecular_weight = 153.823
+    _critical_temperature = Temperature(556.35, "K")
+    _critical_pressure = Pressure(4.56, "MPa") 
+    _critical_volume = Volume(0.276, "m3")  # Placeholder for critical volume per Kmole
+    _critical_zc = 0.272  # Placeholder for critical compressibility factor
+    _critical_acentric_factor = 0.1926  # Placeholder for critical acentric factor
+    _density_constants = [0.99835, 0.274,556.35,0.287]
+    _specific_heat_constants = [-752700,8966.10,-30.394,0.034455,0]
+    _viscosity_constants = [-8.0738,1121.1,-0.4726,0, 0] 
+    _thermal_conductivity_constants = [0.1589, -0.0001987,0,0,0]
+    _vapor_pressure_constants = [78.441,-6128.10,-8.5766,6.85E-06, 2] 
+    _enthalpy_constants = [4.3252E-7, 0.37688, 250.33,3.4528, 0]  # Placeholder for enthalpy constants