processpi 0.0.0__py3-none-any.whl

processpi/units/diameter.py

@@ -0,0 +1,58 @@
+from .base import Variable
+
+class Diameter(Variable):
+    """
+    Represents a Diameter quantity.
+    Default SI unit: meters (m).
+
+    Example:
+    d1 = Diameter(100, "mm")
+    d2 = Diameter(4, "in")
+    """
+
+    _conversion = {
+        "m": 1,
+        "cm": 0.01,
+        "mm": 0.001,
+        "in": 0.0254,
+        "ft": 0.3048
+    }
+
+    def __init__(self, value, units="m"):
+        if value < 0:
+            raise ValueError("Diameter must be non-negative")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for Diameter")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "m")
+        self.original_value = value
+        self.original_unit = units
+
+    def to_base(self) -> float:
+        """Return the base (SI) value in meters."""
+        return self.value
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for Diameter")
+        converted_value = self.value / self._conversion[target_unit]
+        return Diameter(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, Diameter):
+            raise TypeError("Addition only supported between Diameter instances")
+        total = self.value + other.value
+        return Diameter(round(total, 6), "m")
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, self.__class__) and
+            self.to_base() == other.to_base()
+        )
+
+    def __hash__(self):
+        # hash on immutable tuple
+        return hash((self.__class__.__name__, round(self.to_base(), 9)))
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/dimensionless.py

@@ -0,0 +1,42 @@
+from .base import Variable
+
+class Dimensionless(Variable):
+    """
+    Represents a dimensionless quantity (e.g., Reynolds number, friction factor).
+    Default SI unit: none (unitless).
+
+    Example:
+    Re = Dimensionless(5000)   # Reynolds number
+    f = Dimensionless(0.02)    # Friction factor
+    """
+
+    def __init__(self, value):
+        if not isinstance(value, (int, float)):
+            raise TypeError("Dimensionless value must be a number")
+        super().__init__(float(value), "")
+        self.original_value = float(value)
+
+    def to(self, target_unit=None):
+        """
+        Conversion is not applicable, but provided for interface consistency.
+        """
+        return Dimensionless(self.value)
+
+    def __add__(self, other):
+        if not isinstance(other, Dimensionless):
+            raise TypeError("Addition only supported between Dimensionless instances")
+        return Dimensionless(round(self.value + other.value, 6))
+
+    def __mul__(self, other):
+        if isinstance(other, Dimensionless):
+            return Dimensionless(round(self.value * other.value, 6))
+        elif isinstance(other, (int, float)):
+            return Dimensionless(round(self.value * other, 6))
+        else:
+            raise TypeError("Multiplication only supported with Dimensionless or numeric types")
+
+    def __eq__(self, other):
+        return isinstance(other, Dimensionless) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} (dimensionless)"

processpi/units/heat_flux.py

@@ -0,0 +1,46 @@
+from .base import Variable
+
+class HeatFlux(Variable):
+    """
+    Represents Heat Flux (heat transfer rate per unit area).
+    Default SI unit: W/m2 (Watts per square meter)
+
+    Example:
+    q = HeatFlux(300, "W/m²")
+    """
+
+    _conversion = {
+        "W/m2": 1,
+        "kW/m2": 1000,
+        "W/cm2": 10000,
+        "BTU/hft2": 3.1546,  # 1 BTU/hr·ft² ≈ 3.1546 W/m²
+        "cal/scm2": 41840,    # 1 cal/s·cm² ≈ 41840 W/m²
+    }
+
+    def __init__(self, value, units="W/m2"):
+        if value < 0:
+            raise ValueError("Heat flux cannot be negative.")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for HeatFlux")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "W/m2")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for HeatFlux")
+        converted_value = self.value / self._conversion[target_unit]
+        return HeatFlux(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, HeatFlux):
+            raise TypeError("Addition only supported between HeatFlux instances")
+        total = self.value + other.value
+        return HeatFlux(round(total, 6), "W/m2")
+
+    def __eq__(self, other):
+        return isinstance(other, HeatFlux) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/heat_of_vaporization.py

@@ -0,0 +1,47 @@
+from .base import Variable
+
+class HeatOfVaporization(Variable):
+    """
+    Represents Heat of Vaporization.
+    Default SI unit: J/kg (Joules per kilogram)
+
+    Example:
+    hv1 = HeatOfVaporization(2257000)         # 2.257 MJ/kg
+    hv2 = HeatOfVaporization(540, "cal/g")    # 540 cal/g = ~2.259 MJ/kg
+    """
+
+    _conversion = {
+        "J/kg": 1,
+        "kJ/kg": 1e3,
+        "MJ/kg": 1e6,
+        "cal/g": 4184,      # 1 cal/g = 4184 J/kg
+        "BTU/lb": 2326      # 1 BTU/lb ≈ 2326 J/kg
+    }
+
+    def __init__(self, value, units="J/kg"):
+        if value < 0:
+            raise ValueError("Heat of Vaporization must be a non-negative value")
+        if units not in self._conversion:
+            raise ValueError(f"{units} is not a valid unit for Heat of Vaporization")
+        base_value = round(value * self._conversion[units], 10)
+        super().__init__(base_value, "J/kg")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise ValueError(f"{target_unit} is not a valid unit for Heat of Vaporization")
+        converted_value = self.value / self._conversion[target_unit]
+        return HeatOfVaporization(converted_value, target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, HeatOfVaporization):
+            raise TypeError("Addition only allowed between HeatOfVaporization objects")
+        result_in_base = self.value + other.value
+        return HeatOfVaporization(result_in_base / self._conversion[self.original_unit], self.original_unit)
+
+    def __eq__(self, other):
+        return isinstance(other, HeatOfVaporization) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/heat_transfer_coefficient.py

@@ -0,0 +1,45 @@
+from .base import Variable
+
+class HeatTransferCoefficient(Variable):
+    """
+    Represents Heat Transfer Coefficient.
+    Default SI unit: W/m2K (Watts per square meter-Kelvin)
+
+    Example:
+    h = HeatTransferCoefficient(200, "W/m2K")
+    """
+
+    _conversion = {
+        "W/m2K": 1,
+        "kW/m2K": 1000,
+        "cal/scm2C": 41840,          # 1 cal/s·cm²·°C ≈ 41840 W/m²·K
+        "BTU/hft2F": 5.678263,      # 1 BTU/hr·ft²·°F ≈ 5.678263 W/m²·K
+    }
+
+    def __init__(self, value, units="W/m2K"):
+        if value < 0:
+            raise ValueError("Heat transfer coefficient cannot be negative.")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for HeatTransferCoefficient")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "W/m2K")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for HeatTransferCoefficient")
+        converted_value = self.value / self._conversion[target_unit]
+        return HeatTransferCoefficient(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, HeatTransferCoefficient):
+            raise TypeError("Addition only supported between HeatTransferCoefficient instances")
+        total = self.value + other.value
+        return HeatTransferCoefficient(round(total, 6), "W/m2K")
+
+    def __eq__(self, other):
+        return isinstance(other, HeatTransferCoefficient) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/length.py

@@ -0,0 +1,47 @@
+from .base import Variable
+
+class Length(Variable):
+    """
+    Represents a Length quantity Variable.
+    Default SI unit: Meters (m).
+    
+    Example:
+    length = Length(30)           # 30 meters
+    length = Length(30, "in")     # 30 inches
+    """
+
+    _conversion = {
+        "m": 1,
+        "cm": 0.01,
+        "mm": 0.001,
+        "in": 0.0254,
+        "ft": 0.3048
+    }
+
+    def __init__(self, value, units="m"):
+        if value < 0:
+            raise ValueError("Length must be positive")
+        elif units not in self._conversion:
+            raise ValueError(f"{units} is not a valid unit for Length")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "m")  # Always store as base unit (meters)
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise ValueError(f"{target_unit} is not a valid unit for Length")
+        converted_value = self.value / self._conversion[target_unit]
+        return Length(converted_value, target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, Length):
+            raise TypeError("Addition only allowed between Length objects")
+        result_in_base = self.value + other.value
+        return Length(result_in_base / self._conversion[self.original_unit], self.original_unit)
+
+    def __eq__(self, other):
+        return isinstance(other, Length) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/mass.py

@@ -0,0 +1,50 @@
+from .base import Variable
+
+class Mass(Variable):
+    """
+    Represents a Mass quantity.
+    Default SI unit: Kilogram (kg).
+
+    Example:
+    m1 = Mass(500, "g")
+    m2 = Mass(2, "kg")
+    """
+
+    _conversion = {
+        "kg": 1,
+        "g": 0.001,
+        "mg": 0.000001,
+        "ton": 1000,
+        "lb": 0.453592,
+        "oz": 0.0283495,
+        "mt": 1000,         # metric ton
+        "ug": 1e-9
+    }
+
+    def __init__(self, value, units="kg"):
+        if value < 0:
+            raise ValueError("Mass must be non-negative")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for Mass")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "kg")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for Mass")
+        converted_value = self.value / self._conversion[target_unit]
+        return Mass(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, Mass):
+            raise TypeError("Addition only supported between Mass instances")
+        total = self.value + other.value
+        return Mass(round(total, 6), "kg")
+
+    def __eq__(self, other):
+        return isinstance(other, Mass) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/mass_flowrate.py

@@ -0,0 +1,50 @@
+from .base import Variable
+
+class MassFlowRate(Variable):
+    """
+    Represents a Mass Flow Rate quantity.
+    Default SI unit: kilograms per second (kg/s).
+
+    Example:
+    m1 = MassFlowRate(100, "kg/h")
+    m2 = MassFlowRate(0.5, "lb/s")
+    """
+
+    _conversion = {
+        "kg/s": 1,
+        "kg/h": 1 / 3600,
+        "g/s": 0.001,
+        "g/min": 0.001 / 60,
+        "g/h": 0.001 / 3600,
+        "lb/s": 0.453592,
+        "lb/min": 0.453592 / 60,
+        "lb/h": 0.453592 / 3600
+    }
+
+    def __init__(self, value, units="kg/s"):
+        if value < 0:
+            raise ValueError("Mass flow rate must be non-negative")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for MassFlowRate")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "kg/s")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for MassFlowRate")
+        converted_value = self.value / self._conversion[target_unit]
+        return MassFlowRate(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, MassFlowRate):
+            raise TypeError("Addition only supported between MassFlowRate instances")
+        total = self.value + other.value
+        return MassFlowRate(round(total, 6), "kg/s")
+
+    def __eq__(self, other):
+        return isinstance(other, MassFlowRate) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/pressure.py

@@ -0,0 +1,57 @@
+from .base import Variable
+
+class Pressure(Variable):
+    """
+    Represents a Pressure quantity.
+    Default SI unit: Pascal (Pa).
+
+    Example:
+    p1 = Pressure(1, "atm")
+    p2 = Pressure(101325, "Pa")
+    """
+
+    _conversion = {
+        "Pa": 1,
+        "kPa": 1_000,
+        "MPa": 1_000_000,
+        "bar": 100_000,
+        "atm": 101_325,
+        "psi": 6_894.76,
+        "mmHg": 133.322,
+        "torr": 133.322
+    }
+
+    def __init__(self, value, units="Pa"):
+        if value < 0:
+            raise ValueError("Pressure must be non-negative")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for Pressure")
+        super().__init__(value, units)
+
+    def to_base(self):
+        """Convert to base SI unit (Pa)."""
+        return self.value * self._conversion[self.units]
+
+    def from_base(self, base_value: float, target_units: str):
+        """Convert from Pa to target units."""
+        if target_units not in self._conversion:
+            raise TypeError(f"{target_units} is not a valid unit for Pressure")
+        return base_value / self._conversion[target_units]
+
+    def to(self, target_unit):
+        """Return new Pressure in target units."""
+        base_value = self.to_base()
+        converted_value = self.from_base(base_value, target_unit)
+        return Pressure(round(converted_value, 4), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, Pressure):
+            raise TypeError("Addition only supported between Pressure instances")
+        total_base = self.to_base() + other.to_base()
+        return Pressure(self.from_base(total_base, "Pa"), "Pa")
+
+    def __eq__(self, other):
+        return isinstance(other, Pressure) and self.to_base() == other.to_base()
+
+    def __repr__(self):
+        return f"{self.value} {self.units}"

processpi/units/specific_heat.py

@@ -0,0 +1,47 @@
+from .base import Variable
+
+class SpecificHeat(Variable):
+    """
+    Represents Specific Heat Capacity.
+    Default SI unit: kJ/kgK
+
+    Example:
+    cp1 = SpecificHeat(4.186, "kJ/kgK")
+    cp2 = SpecificHeat(1.0, "cal/gK")
+    """
+
+    _conversion = {
+        "kJ/kgK": 1,
+        "J/kgK": 0.001,
+        "cal/gK": 4.1868 * 0.001,   # 1 cal/g.K = 4.1868 kJ/kg.K
+        "BTU/lbF": 4.1868 * 2.326,  # approx conversion to kJ/kg.K
+        "kcal/kgK": 4.1868
+    }
+
+    def __init__(self, value, units="kJ/kgK"):
+        if value < 0:
+            raise ValueError("Specific heat must be positive.")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for SpecificHeat")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "kJ/kgK")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for SpecificHeat")
+        converted_value = self.value / self._conversion[target_unit]
+        return SpecificHeat(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, SpecificHeat):
+            raise TypeError("Addition only supported between SpecificHeat instances")
+        total = self.value + other.value
+        return SpecificHeat(round(total, 6), "kJ/kgK")
+
+    def __eq__(self, other):
+        return isinstance(other, SpecificHeat) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/strings.py

@@ -0,0 +1,31 @@
+from .base import Variable
+
+class StringUnit(Variable):
+    """
+    Represents a string-based categorical quantity (e.g., flow type, phase, material category).
+    Default unit: none (string).
+
+    Example:
+    flow = StringUnit("Laminar", "flow_type")
+    phase = StringUnit("Gas", "phase_state")
+    """
+
+    def __init__(self, value: str, category: str = "string"):
+        if not isinstance(value, str):
+            raise TypeError("StringUnit value must be a string")
+        super().__init__(value, category)
+        self.original_value = value
+        self.category = category
+
+    def to(self, target_unit=None):
+        """
+        Conversion is not applicable for string-based units.
+        Provided only for interface consistency.
+        """
+        return StringUnit(self.value, self.category)
+
+    def __eq__(self, other):
+        return isinstance(other, StringUnit) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} ({self.category})"

processpi/units/temperature.py

@@ -0,0 +1,51 @@
+from .base import Variable
+
+class Temperature(Variable):
+    """
+    Represents a Temperature quantity.
+    Default SI unit: Kelvin (K).
+
+    Example:
+    t1 = Temperature(100, "C")      # 100°C
+    t2 = Temperature(373.15)        # 373.15 K
+    """
+
+    _conversion = {
+        "K": lambda x: x,
+        "C": lambda x: x + 273.15,
+        "F": lambda x: (x - 32) * 5 / 9 + 273.15
+    }
+
+    _reverse_conversion = {
+        "K": lambda x: x,
+        "C": lambda x: x - 273.15,
+        "F": lambda x: (x - 273.15) * 9 / 5 + 32
+    }
+
+    def __init__(self, value, units="K"):
+        if units not in self._conversion:
+            raise ValueError(f"{units} is not a valid unit for Temperature")
+        base_value = round(self._conversion[units](value), 4)
+        super().__init__(base_value, "K")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._reverse_conversion:
+            raise ValueError(f"{target_unit} is not a valid target unit for Temperature")
+        converted_value = self._reverse_conversion[target_unit](self.value)
+        return Temperature(round(converted_value, 4), target_unit)
+
+    def __add__(self, other):
+        raise TypeError("Direct addition of two temperatures is not physically meaningful")
+
+    def __sub__(self, other):
+        if not isinstance(other, Temperature):
+            raise TypeError("Subtraction only allowed between Temperature objects")
+        return self.value - other.value  # Difference in Kelvin
+
+    def __eq__(self, other):
+        return isinstance(other, Temperature) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/thermal_conductivity.py

@@ -0,0 +1,45 @@
+from .base import Variable
+
+class ThermalConductivity(Variable):
+    """
+    Represents Thermal Conductivity of a material.
+    Default SI unit: W/mK (Watts per meter-Kelvin)
+
+    Example:
+    k = ThermalConductivity(0.5, "W/mK")
+    """
+
+    _conversion = {
+        "W/mK": 1,
+        "kW/mK": 1000,
+        "cal/scmC": 418.4,       # 1 cal/s·cm·°C ≈ 418.4 W/m·K
+        "BTU/hrftF": 1.730735,   # 1 BTU/hr·ft·°F ≈ 1.730735 W/m·K
+    }
+
+    def __init__(self, value, units="W/mK"):
+        if value < 0:
+            raise ValueError("Thermal conductivity cannot be negative.")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for ThermalConductivity")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "W/mK")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for ThermalConductivity")
+        converted_value = self.value / self._conversion[target_unit]
+        return ThermalConductivity(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, ThermalConductivity):
+            raise TypeError("Addition only supported between ThermalConductivity instances")
+        total = self.value + other.value
+        return ThermalConductivity(round(total, 6), "W/mK")
+
+    def __eq__(self, other):
+        return isinstance(other, ThermalConductivity) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"

processpi/units/thermal_resistance.py

@@ -0,0 +1,46 @@
+from .base import Variable
+
+class ThermalResistance(Variable):
+    """
+    Represents Thermal Resistance.
+    Default SI unit: K/W (Kelvin per Watt)
+
+    Example:
+    r1 = ThermalResistance(0.5, "K/W")
+    r2 = ThermalResistance(2, "C/W")
+    """
+
+    _conversion = {
+        "K/W": 1,
+        "C/W": 1,      # °C/W is numerically equivalent to K/W
+        "hrft2F/BTU": 0.1761,  # 1 hr·ft²·°F/BTU ≈ 0.1761 K/W
+        "m2K/W": 1,   # often used in building materials
+    }
+
+    def __init__(self, value, units="K/W"):
+        if value <= 0:
+            raise ValueError("Thermal resistance must be positive.")
+        if units not in self._conversion:
+            raise TypeError(f"{units} is not a valid unit for ThermalResistance")
+        base_value = round(value * self._conversion[units], 6)
+        super().__init__(base_value, "K/W")
+        self.original_value = value
+        self.original_unit = units
+
+    def to(self, target_unit):
+        if target_unit not in self._conversion:
+            raise TypeError(f"{target_unit} is not a valid unit for ThermalResistance")
+        converted_value = self.value / self._conversion[target_unit]
+        return ThermalResistance(round(converted_value, 6), target_unit)
+
+    def __add__(self, other):
+        if not isinstance(other, ThermalResistance):
+            raise TypeError("Addition only supported between ThermalResistance instances")
+        total = self.value + other.value
+        return ThermalResistance(round(total, 6), "K/W")
+
+    def __eq__(self, other):
+        return isinstance(other, ThermalResistance) and self.value == other.value
+
+    def __repr__(self):
+        return f"{self.original_value} {self.original_unit}"