processpi 0.0.0__py3-none-any.whl

processpi/pipelines/equipment.py

@@ -0,0 +1,32 @@
+
+class Equipment:
+    """
+    Generic inline process equipment with inlet, outlet, and pressure drop.
+    Can represent filters, heat exchangers, valves, or other unit operations.
+    """
+    def __init__(self, name: str, pressure_drop: float = 0.0, description: str = ""):
+        """
+        Initialize Equipment.
+
+        Args:
+            name (str): Equipment name.
+            pressure_drop (float): Pressure drop across equipment (bar).
+            description (str): Optional description (e.g., 'Heat Exchanger', 'Filter').
+        """
+        self.name = name
+        self.pressure_drop = pressure_drop
+        self.description = description
+        self.inlet_nodes = []
+        self.outlet_nodes = []
+
+    def add_inlet(self, node):
+        """Attach an inlet node to the equipment."""
+        self.inlet_nodes.append(node)
+
+    def add_outlet(self, node):
+        """Attach an outlet node to the equipment."""
+        self.outlet_nodes.append(node)
+
+    def __repr__(self):
+        return (f"Equipment({self.name}, ΔP={self.pressure_drop} bar, "
+                f"Desc='{self.description}')")

processpi/pipelines/fittings.py

@@ -0,0 +1,76 @@
+# processpi/pipelines/fittings.py
+
+from typing import Optional, Dict, Union
+from .base import PipelineBase
+from ..units import *
+from .standards import EQUIVALENT_LENGTHS, K_FACTORS
+
+
+class Fitting(PipelineBase):
+    """
+    Represents a pipeline fitting or valve with either equivalent length or K-factor.
+
+    Attributes:
+        fitting_type (str): Type of fitting/valve (e.g., 'gate_valve_open', 'globe_valve').
+        diameter (float): Inside diameter of the pipe (mm).
+        quantity (int): Number of fittings of this type.
+    """
+
+    def __init__(
+        self,
+        fitting_type: str,
+        diameter: Diameter,
+        quantity: int = 1,
+    ):
+        self.fitting_type = fitting_type
+        self.diameter = diameter
+        self.quantity = quantity
+
+        # Load equivalent length factor if available
+        self.le_factor = EQUIVALENT_LENGTHS.get(fitting_type, None)
+
+        # Load K-factor if available
+        self.K = K_FACTORS.get(fitting_type, None)
+
+    def equivalent_length(self) -> Optional[float]:
+        """
+        Calculate equivalent length of the fitting(s) in meters.
+
+        Returns:
+            float: Equivalent length (m) or None if not defined.
+        """
+        if self.le_factor is None:
+            return None
+        dj_m = self.diameter / 1000  # mm → m
+        return self.le_factor * dj_m * self.quantity
+
+    def total_K(self) -> Optional[float]:
+        """
+        Calculate total K-factor for the fitting(s).
+
+        Returns:
+            float: Total K-factor or None if not defined.
+        """
+        if self.K is None:
+            return None
+        return self.K * self.quantity
+
+    def to_dict(self) -> Dict[str, Union[str, float, None]]:
+        """
+        Export fitting properties as dictionary for reporting.
+        """
+        return {
+            "fitting_type": self.fitting_type,
+            "diameter_mm": self.diameter,
+            "quantity": self.quantity,
+            "le_factor": self.le_factor,
+            "equivalent_length_m": self.equivalent_length(),
+            "K": self.K,
+            "total_K": self.total_K(),
+        }
+
+    def calculate(self):
+        """
+        Perform the pipeline calculation (placeholder).
+        """
+        return self.to_dict()

processpi/pipelines/materials.py

@@ -0,0 +1,102 @@
+# processpi/pipelines/materials.py
+
+"""
+Pipeline Materials Specifications and Properties
+
+This module contains physical and mechanical properties of
+pipeline materials commonly used in process industries.
+
+All values are representative and may vary depending on
+standards (ASME, ASTM, ISO) and manufacturer data.
+"""
+
+from typing import Dict, Any
+
+
+# Dictionary of material properties
+MATERIAL_PROPERTIES: Dict[str, Dict[str, Any]] = {
+    "CS": {  # Carbon Steel
+        "density": 7850,               # kg/m³
+        "thermal_conductivity": 54,    # W/m·K
+        "roughness": 0.045,            # mm
+        "max_temp": 425,               # °C (approximate)
+        "allowable_stress": 138,       # MPa
+        "notes": "Standard carbon steel pipes, widely used in process piping."
+    },
+    "SS304": {  # Stainless Steel 304
+        "density": 8000,               
+        "thermal_conductivity": 16.2,
+        "roughness": 0.015,
+        "max_temp": 870,
+        "allowable_stress": 137,
+        "notes": "Good corrosion resistance, general chemical service."
+    },
+    "SS316": {  # Stainless Steel 316
+        "density": 8000,
+        "thermal_conductivity": 16.3,
+        "roughness": 0.015,
+        "max_temp": 925,
+        "allowable_stress": 137,
+        "notes": "Better corrosion resistance than SS304, widely used in chemical plants."
+    },
+    "PVC": {  # Polyvinyl Chloride
+        "density": 1380,
+        "thermal_conductivity": 0.19,
+        "roughness": 0.0015,
+        "max_temp": 60,
+        "allowable_stress": 13.8,
+        "notes": "Lightweight, used in water and low-pressure service."
+    },
+    "CPVC": {  # Chlorinated Polyvinyl Chloride
+        "density": 1500,
+        "thermal_conductivity": 0.14,
+        "roughness": 0.0015,
+        "max_temp": 90,
+        "allowable_stress": 17,
+        "notes": "Higher temperature resistance than PVC."
+    },
+    "HDPE": {  # High Density Polyethylene
+        "density": 950,
+        "thermal_conductivity": 0.42,
+        "roughness": 0.007,
+        "max_temp": 60,
+        "allowable_stress": 5,
+        "notes": "Corrosion resistant, flexible, low-pressure applications."
+    },
+    "Copper": {
+        "density": 8960,
+        "thermal_conductivity": 401,
+        "roughness": 0.0015,
+        "max_temp": 200,
+        "allowable_stress": 70,
+        "notes": "Excellent thermal conductivity, used in heat exchangers."
+    }
+}
+
+
+def get_material_property(material: str, prop: str) -> Any:
+    """
+    Get a specific property of a pipeline material.
+    
+    Args:
+        material (str): Material code (e.g., 'CS', 'SS316', 'PVC').
+        prop (str): Property name (e.g., 'density', 'roughness').
+
+    Returns:
+        Any: Property value if found, else None.
+    """
+    return MATERIAL_PROPERTIES.get(material, {}).get(prop)
+
+
+def get_material_data(material: str) -> Dict[str, Any]:
+    """
+    Get all properties for a given pipeline material.
+    
+    Args:
+        material (str): Material code.
+    
+    Returns:
+        dict: Dictionary of material properties.
+    """
+    return MATERIAL_PROPERTIES.get(material, {})
+

processpi/pipelines/network.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+from typing import List, Dict, Union, Optional, Any
+
+from .pipes import Pipe
+from .fittings import Fitting
+from .vessel import Vessel
+from .pump import Pump
+from .equipment import Equipment
+
+
+class Node:
+    """Node represents a junction or endpoint in the pipeline network."""
+    def __init__(self, name: str, elevation: float = 0.0):
+        self.name = name
+        self.elevation = elevation
+
+    def __repr__(self):
+        return f"Node({self.name}, elevation={self.elevation})"
+
+
+# A branch in a parallel block can be either a PipelineNetwork or a single element
+Branch = Union["PipelineNetwork", Pipe, Fitting, Pump, Vessel, Equipment]
+
+
+class PipelineNetwork:
+    """
+    Framework for defining a process pipeline network consisting of pipes,
+    fittings, pumps, vessels, equipment, and sub-networks.
+
+    This version supports both node/edge construction AND composable
+    series/parallel blocks compatible with the PipelineEngine:
+      - connection_type: "series" (default) or "parallel"
+      - elements: a list of elements or child PipelineNetwork objects
+    """
+
+    # ---------------- Init ----------------
+    def __init__(self, name: str, connection_type: Optional[str] = "series"):
+        if connection_type not in (None, "series", "parallel"):
+            raise ValueError("connection_type must be 'series' or 'parallel' (or None which defaults to 'series').")
+        self.name = name
+        self.nodes: Dict[str, Node] = {}
+        self.elements: List[Branch] = []
+        self.connection_type: str = connection_type or "series"
+
+    # ---------------- Convenience constructors (engine-friendly) -------------
+    @staticmethod
+    def series(name: str, *elements: Branch) -> "PipelineNetwork":
+        """Create a series block populated with elements."""
+        net = PipelineNetwork(name=name, connection_type="series")
+        net.elements.extend(elements)
+        return net
+
+    @staticmethod
+    def parallel(name: str, *branches: Branch) -> "PipelineNetwork":
+        """Create a parallel block populated with branch elements or child networks."""
+        net = PipelineNetwork(name=name, connection_type="parallel")
+        net.elements.extend(branches)
+        return net
+
+    # ---------------- Composable builders ------------------------------------
+    def add(self, *elements: Branch) -> "PipelineNetwork":
+        """Append one or more elements to the current block (series or parallel)."""
+        self.elements.extend(elements)
+        return self
+
+    def add_series(self, *elements: Branch) -> "PipelineNetwork":
+        """
+        Add a series group. If the current block is series, append directly.
+        If current block is parallel, wrap as a child series network (a branch).
+        """
+        if self.connection_type == "series":
+            self.elements.extend(elements)
+            return self
+        series_child = PipelineNetwork(name=f"{self.name}-series-{len(self.elements)+1}", connection_type="series")
+        series_child.elements.extend(elements)
+        self.elements.append(series_child)
+        return self
+
+    def add_parallel(self, *branches: Branch) -> "PipelineNetwork":
+        """
+        Add a parallel group. If current block is parallel, append as new branches.
+        If current block is series, wrap as a child parallel network (one element).
+        """
+        if self.connection_type == "parallel":
+            self.elements.extend(branches)
+            return self
+        par_child = PipelineNetwork(name=f"{self.name}-parallel-{len(self.elements)+1}", connection_type="parallel")
+        par_child.elements.extend(branches)
+        self.elements.append(par_child)
+        return self
+
+    # ---------------- Node Management ----------------
+    def add_node(self, name: str, elevation: float = 0.0) -> Node:
+        """Add a node (junction) to the network."""
+        if name in self.nodes:
+            raise ValueError(f"Node '{name}' already exists in the network.")
+        node = Node(name, elevation)
+        self.nodes[name] = node
+        return node
+
+    def get_node(self, name: str) -> Node:
+        """Fetch an existing node by name."""
+        if name not in self.nodes:
+            raise KeyError(f"Node '{name}' does not exist in the network.")
+        return self.nodes[name]
+
+    # ---------------- Edge Management ----------------
+    def add_edge(self, component: Union[Pipe, Pump, Vessel, Equipment], start_node: str, end_node: str = None):
+        """
+        Add a connection (edge) between nodes with strict validation.
+        Edges added here are automatically appended to this block's elements.
+        """
+        if start_node not in self.nodes:
+            raise ValueError(f"Start node '{start_node}' not found in network.")
+
+        # Prevent start=end self-loops
+        if end_node and start_node == end_node:
+            raise ValueError(f"Cannot create self-loop on node '{start_node}'.")
+
+        if isinstance(component, (Pipe, Pump)):
+            if not end_node or end_node not in self.nodes:
+                raise ValueError(f"End node '{end_node}' not found in network.")
+            component.start_node = self.nodes[start_node]
+            component.end_node = self.nodes[end_node]
+
+        elif isinstance(component, (Vessel, Equipment)):
+            if not end_node or end_node not in self.nodes:
+                raise ValueError(f"Outlet node '{end_node}' not found in network.")
+            component.add_inlet(self.nodes[start_node])
+            component.add_outlet(self.nodes[end_node])
+
+        else:
+            raise TypeError(f"Unsupported component type '{type(component).__name__}'.")
+
+        self.elements.append(component)
+
+    # ---------------- Element Management ----------------
+    def add_fitting(self, fitting: Fitting, at_node: str):
+        """Add a fitting at a specific node."""
+        if at_node not in self.nodes:
+            raise ValueError(f"Node '{at_node}' must exist in the network.")
+        fitting.node = self.nodes[at_node]
+        self.elements.append(fitting)
+
+    def add_subnetwork(self, subnetwork: "PipelineNetwork", connection_type: str):
+        """
+        Add a subnetwork (series or parallel) as a child element.
+        This preserves compatibility with existing code that constructs subnetworks separately.
+        """
+        if connection_type not in ["series", "parallel"]:
+            raise ValueError("connection_type must be 'series' or 'parallel'")
+        if subnetwork is self:
+            raise ValueError("Cannot add the network as a subnetwork of itself.")
+        subnetwork.connection_type = connection_type
+        self.elements.append(subnetwork)
+
+    # ---------------- Validation ----------------
+    def validate(self):
+        """Check for common network errors and raise descriptive exceptions."""
+        errors = []
+
+        # Collect connected node names from elements in this block only
+        connected = set()
+        for elem in self.elements:
+            if isinstance(elem, (Pipe, Pump)):
+                if getattr(elem, "start_node", None) and getattr(elem, "end_node", None):
+                    connected.update([elem.start_node.name, elem.end_node.name])
+            elif isinstance(elem, (Vessel, Equipment)):
+                for n in getattr(elem, "inlet_nodes", []) or []:
+                    connected.add(n.name)
+                for n in getattr(elem, "outlet_nodes", []) or []:
+                    connected.add(n.name)
+            elif isinstance(elem, PipelineNetwork):
+                # recurse into child blocks for validation too
+                try:
+                    elem.validate()
+                except ValueError as e:
+                    errors.append(f"In subnetwork '{elem.name}': {e}")
+
+        for node_name in self.nodes:
+            if node_name not in connected:
+                errors.append(f"Node '{node_name}' is not connected to any component.")
+
+        # in PipelineNetwork.validate()
+        for elem in self.elements:
+            if isinstance(elem, Fitting):
+                if not isinstance(elem.diameter, Diameter):
+                    errors.append(f"Fitting '{elem.fitting_type}' requires 'diameter' as Diameter unit.")
+                if elem.total_K() is None and elem.equivalent_length() is None:
+                    errors.append(f"Fitting '{elem.fitting_type}' has neither K nor equivalent length in standards.")
+            if elem.__class__.__name__ == "Pump":
+                if (getattr(elem, "head", 0) in (None, 0)) and not (getattr(elem, "inlet_pressure", None) and getattr(elem, "outlet_pressure", None)):
+                    errors.append("Pump requires either (inlet & outlet pressures) or a non-zero head.")
+            if elem.__class__.__name__ == "Equipment":
+                if getattr(elem, "pressure_drop", 0.0) is None:
+                    errors.append(f"Equipment '{getattr(elem, 'name', 'equipment')}' requires 'pressure_drop' (bar).")
+
+
+        if errors:
+            raise ValueError("Network validation failed:\n" + "\n".join(errors))
+        return True
+
+    # ---------------- Description ----------------
+    def describe(self, level: int = 0) -> str:
+        """Return a string representation of the network hierarchy."""
+        indent = "  " * level
+        desc = f"{indent}Network: {self.name} (connection: {self.connection_type})\n"
+        for node in self.nodes.values():
+            desc += f"{indent}  Node: {node.name}, Elevation={node.elevation} m\n"
+        for element in self.elements:
+            if isinstance(element, Pipe):
+                desc += (
+                    f"{indent}  Pipe: {getattr(element, 'nominal_diameter', 'NA')} mm, "
+                    f"{getattr(element, 'length', 'NA')} m, {getattr(element, 'material', 'NA')}, "
+                    f"from {element.start_node.name} → {element.end_node.name}\n"
+                )
+            elif isinstance(element, Pump):
+                desc += (
+                    f"{indent}  Pump: {getattr(element, 'pump_type', 'Generic')}, "
+                    f"from {element.start_node.name} → {element.end_node.name}, "
+                    f"Head={getattr(element, 'head', 'NA')} m, Power={getattr(element, 'power', 'NA')} kW\n"
+                )
+            elif isinstance(element, Vessel):
+                inlets = ", ".join([n.name for n in getattr(element, "inlet_nodes", [])])
+                outlets = ", ".join([n.name for n in getattr(element, "outlet_nodes", [])])
+                desc += f"{indent}  Vessel: {getattr(element, 'name', 'Vessel')}, Volume={getattr(element, 'volume', 'NA')} m³, P={getattr(element, 'pressure', 'NA')} bar, T={getattr(element, 'temperature', 'NA')}°C\n"
+                desc += f"{indent}    Inlets: {inlets or '—'}\n"
+                desc += f"{indent}    Outlets: {outlets or '—'}\n"
+            elif isinstance(element, Equipment):
+                inlets = ", ".join([n.name for n in getattr(element, "inlet_nodes", [])])
+                outlets = ", ".join([n.name for n in getattr(element, "outlet_nodes", [])])
+                desc += (f"{indent}  Equipment: {getattr(element, 'name', 'Equipment')}, "
+                         f"ΔP={getattr(element, 'pressure_drop', 'NA')} bar, "
+                         f"Type={getattr(element, 'description', 'Generic')}\n")
+                desc += f"{indent}    Inlet(s): {inlets or '—'}\n"
+                desc += f"{indent}    Outlet(s): {outlets or '—'}\n"
+            elif isinstance(element, Fitting):
+                where = getattr(element, 'node', None)
+                at = where.name if where else "unknown"
+                desc += f"{indent}  Fitting: {getattr(element, 'fitting_type', 'Fitting')}, at {at}\n"
+            elif isinstance(element, PipelineNetwork):
+                desc += element.describe(level + 1)
+        return desc
+
+    # ---------------- ASCII Schematic (engine-friendly) ----------------------
+    def _schematic_lines(self, prefix: str = "") -> List[str]:
+        lines: List[str] = []
+        header = f"{prefix}{self.name} [{self.connection_type}]"
+        lines.append(header)
+        child_prefix = prefix + "  "
+        if self.connection_type == "series":
+            for i, el in enumerate(self.elements, start=1):
+                if isinstance(el, PipelineNetwork):
+                    lines.extend(el._schematic_lines(child_prefix))
+                else:
+                    label = getattr(el, "name", el.__class__.__name__)
+                    lines.append(f"{child_prefix}{i}. {label}")
+        else:  # parallel
+            for i, br in enumerate(self.elements, start=1):
+                if isinstance(br, PipelineNetwork):
+                    lines.append(f"{child_prefix}(branch {i})")
+                    lines.extend(br._schematic_lines(child_prefix + "  "))
+                else:
+                    label = getattr(br, "name", br.__class__.__name__)
+                    lines.append(f"{child_prefix}├─(branch {i}) {label}")
+        return lines
+
+    def schematic(self, level: int = 0) -> str:
+        """
+        Generate ASCII schematic representation of the pipeline network.
+        Kept compatible with the PipelineEngine which calls `network.schematic()`.
+        """
+        return "\n".join(self._schematic_lines())
+
+    # ---------------- Python niceties ----------------------------------------
+    def __repr__(self) -> str:
+        return f"PipelineNetwork(name={self.name!r}, type={self.connection_type!r}, elements={len(self.elements)})"

processpi/pipelines/pipelineresults.py

@@ -0,0 +1,95 @@
+# processpi/pipelines/pipelineresults.py
+
+from typing import Dict, Any
+from ..units import Diameter, Length, Pressure
+
+class PipelineResults:
+    def __init__(self, results: dict):
+        self.results = results
+
+    def summary(self):
+        """Print a clean, human-readable summary of the last run."""
+        results = self.results
+        if not results:
+            print("No results available. Run the engine first.")
+            return
+
+        print("\n=== Pipeline Summary ===")
+
+        # -------------------- Network summary --------------------
+        summary = results.get("summary", {})
+        if summary:
+            inlet_flow = summary.get("inlet_flow_m3_s")
+            total_dp = summary.get("total_pressure_drop_Pa")
+            if inlet_flow:
+                fval = inlet_flow.value if hasattr(inlet_flow, "value") else inlet_flow
+                print(f"Inlet Flow: {fval:.3f} m³/s")
+            if total_dp:
+                fval = total_dp.value if hasattr(total_dp, "value") else total_dp
+                print(f"Total Pressure Drop: {fval:.2f} Pa")
+
+        # -------------------- Single Pipe Mode --------------------
+        if results.get("mode") == "single":
+            pipe_data = results.get("pipe", {})
+            d = pipe_data.get("internal_diameter")
+            l = pipe_data.get("length")
+            v = results.get("velocity_m_s")
+            Re = results.get("reynolds_number")
+            f = results.get("friction_factor")
+            dp = results.get("pressure_drop_Pa")
+
+            print("\n--- Single Pipe ---")
+            if d:
+                print(f"Pipe Internal Diameter: {d.value:.2f} mm")
+            if l:
+                print(f"Pipe Length: {l.value:.2f} m")
+            if v:
+                print(f"Velocity: {v.value:.3f} m/s")
+            if Re is not None:
+                re_val = Re.value if hasattr(Re, "value") else Re
+                print(f"Reynolds Number: {re_val:.0f}")
+            if f is not None:
+                fval = f.value if hasattr(f, "value") else f
+                print(f"Friction Factor: {fval:.4f}")
+            if dp:
+                print(f"Pressure Drop: {dp.value:.2f} Pa")
+
+        # -------------------- Network / Multiple Pipes --------------------
+        pipes = results.get("pipes", [])
+        if pipes:
+            print("\n--- Pipe & Fitting Details ---")
+            for p in pipes:
+                if p["type"] == "pipe":
+                    d = p.get("diameter_m")
+                    v = p.get("velocity_m_s")
+                    Re = p.get("reynolds_number")
+                    f = p.get("friction_factor")
+                    dp = p.get("pressure_drop_Pa")
+                    print(f"\nPipe: {p.get('name','pipe')}")
+                    if d:
+                        d_val = d.value if hasattr(d, "value") else d
+                        print(f"  Diameter: {d_val:.2f} mm")
+                    if v:
+                        v_val = v.value if hasattr(v, "value") else v
+                        print(f"  Velocity: {v_val:.3f} m/s")
+                    if Re is not None:
+                        re_val = Re.value if hasattr(Re, "value") else Re
+                        print(f"  Reynolds #: {re_val:.0f}")
+                    if f is not None:
+                        f_val = f.value if hasattr(f, "value") else f
+                        print(f"  Friction Factor: {f_val:.4f}")
+                    if dp:
+                        dp_val = dp.value if hasattr(dp, "value") else dp
+                        print(f"  Pressure Drop: {dp_val:.2f} Pa")
+                elif p["type"] == "fitting":
+                    dp = p.get("pressure_drop_Pa")
+                    print(f"\nFitting: {p.get('name','fitting')}")
+                    print(f"  K-factor: {p.get('K')}")
+                    if dp:
+                        dp_val = dp.value if hasattr(dp, "value") else dp
+                        print(f"  Pressure Drop: {dp_val:.2f} Pa")
+
+        # -------------------- Schematic --------------------
+        if "schematic" in results:
+            print("\n=== Schematic ===")
+            print(results["schematic"])

processpi/pipelines/pipes.py

@@ -0,0 +1,84 @@
+# processpi/pipelines/pipes.py
+
+from typing import Optional, Dict
+from .base import PipelineBase
+from ..units import *
+from .standards import get_roughness, get_internal_diameter
+
+
+class Pipe(PipelineBase):
+    """
+    Represents a process pipeline element with geometric and material properties.
+
+    Attributes:
+        nominal_diameter (Diameter): Nominal diameter of the pipe (mm or inch).
+        schedule (str): Pipe schedule (e.g., '40', '80', 'STD', 'XS').
+        material (str): Pipe material (e.g., 'CS', 'SS316', 'PVC').
+        length (Length): Length of the pipe.
+        roughness (float): Absolute roughness of the pipe (mm).
+        internal_diameter (Diameter): Internal diameter based on nominal diameter and schedule.
+        inlet_pressure (Pressure): Optional inlet pressure for the pipe.
+        outlet_pressure (Pressure): Optional outlet pressure for the pipe.
+    """
+
+    def __init__(
+        self,
+        nominal_diameter: Diameter,
+        schedule: str = "40",
+        material: str = "CS",
+        length: Optional[Length] = None,
+        inlet_pressure: Optional[Pressure] = None,
+        outlet_pressure: Optional[Pressure] = None,
+    ):
+        self.nominal_diameter = nominal_diameter
+        self.schedule = schedule
+        self.material = material
+        self.length = length or Length(1.0, "m")  # default 1 meter
+        self.roughness = get_roughness(self.material)
+        self.internal_diameter = get_internal_diameter(self.nominal_diameter, self.schedule)
+        self.inlet_pressure = inlet_pressure  # user can set this explicitly
+        self.outlet_pressure = outlet_pressure  # user can set this explicitly
+
+    def cross_sectional_area(self) -> float:
+        """
+        Calculate cross-sectional flow area (m²).
+        """
+        d_m = self.internal_diameter.to("m").value
+        return 3.14159 * (d_m / 2) ** 2
+
+    def surface_area(self) -> float:
+        """
+        Calculate external surface area (m²) for heat loss calculations.
+        """
+        d_m = self.nominal_diameter.to("m").value
+        return 3.14159 * d_m * self.length.to("m").value
+
+    def pressure_difference(self) -> Optional[Pressure]:
+        """
+        Calculate the pressure difference (inlet - outlet) if both are defined.
+        """
+        if self.inlet_pressure and self.outlet_pressure:
+            return self.inlet_pressure - self.outlet_pressure
+        return None
+
+    def to_dict(self) -> Dict[str, Optional[float]]:
+        """
+        Export pipe properties as dictionary for reporting.
+        """
+        return {
+            "nominal_diameter_mm": self.nominal_diameter.value,
+            "schedule": self.schedule,
+            "material": self.material,
+            "length_m": self.length.to("m").value,
+            "roughness_mm": self.roughness,
+            "internal_diameter_mm": self.internal_diameter.value if self.internal_diameter else None,
+            "inlet_pressure_Pa": self.inlet_pressure.to("Pa").value if self.inlet_pressure else None,
+            "outlet_pressure_Pa": self.outlet_pressure.to("Pa").value if self.outlet_pressure else None,
+            "pressure_difference_Pa": self.pressure_difference().to("Pa").value if self.pressure_difference() else None,
+        }
+
+    def calculate(self):
+        """
+        Placeholder for pipe-specific calculations.
+        """
+        pass