steady_state Function

Overview

The steady_state function provides unified steady-state analysis capabilities across all transport models in the continuous liquid module. This function enables comparative analysis and model selection for process control applications.

Function Description

The steady_state function implements steady-state calculations for fluid transport systems, providing equilibrium solutions for pressure, temperature, flow rate, and concentration distributions. Each transport model implements its specific steady-state behavior while maintaining a consistent interface.

Key Features

• Model-Agnostic Interface: Consistent input/output format across models

• Comparative Analysis: Side-by-side model performance evaluation

• Parameter Sensitivity: Analysis of input parameter effects

• Design Point Calculation: Operating point determination

• Performance Mapping: Model capability assessment

Mathematical Framework

The steady-state analysis solves the equilibrium equations for each transport model:

General Form:

\[\frac{dx}{dt} = f(x, u) = 0\]

Where: - \(x\) = state vector (pressure, temperature, concentration) - \(u\) = input vector (boundary conditions, flow rates) - \(f\) = model-specific dynamics function

Model-Specific Implementations:

PipeFlow: Darcy-Weisbach pressure drop with thermal effects PeristalticFlow: Positive displacement flow with backpressure correction SlurryPipeline: Multiphase pressure drop with settling effects

Input/Output Formats

Each model has specific input and output formats optimized for its application:

# PipeFlow
inputs = [P_inlet, T_inlet, flow_rate]       # [Pa, K, m³/s]
outputs = [P_outlet, T_outlet]               # [Pa, K]

# PeristalticFlow
inputs = [P_inlet, pump_speed, occlusion]    # [Pa, RPM, -]
outputs = [flow_rate, P_outlet]              # [m³/s, Pa]

# SlurryPipeline
inputs = [P_inlet, flow_rate, c_solid]       # [Pa, m³/s, -]
outputs = [P_outlet, c_solid_out]            # [Pa, -]

Usage Examples

Cross-Model Comparison

#!/usr/bin/env python3
"""
steady_state Function Example
=============================
Demonstration of the steady_state function for process control transport models.

This example shows how to use the steady_state function with different transport models
including PipeFlow, PeristalticFlow, and SlurryPipeline.
"""

import numpy as np
import matplotlib
matplotlib.use('Agg')  # Use non-GUI backend
import matplotlib.pyplot as plt
from PipeFlow import PipeFlow
from PeristalticFlow import PeristalticFlow
from SlurryPipeline import SlurryPipeline

def main():
    """Main function demonstrating steady_state function usage"""
    print("steady_state Function Example")
    print("=============================")
    print("Demonstration of steady_state function across transport models")
    print("Timestamp: 2025-07-09")
    print("=" * 60)
    
    # Example 1: PipeFlow steady_state
    print("\nEXAMPLE 1: PipeFlow steady_state Function")
    print("-" * 45)
    
    pipe = PipeFlow(
        pipe_length=1000.0,      # 1 km
        pipe_diameter=0.2,       # 20 cm
        roughness=1e-4,          # Steel pipe
        fluid_density=1000.0,    # Water
        fluid_viscosity=1e-3,    # Water viscosity
        name="SteadyStatePipe"
    )
    
    print(f"Model: {pipe.name}")
    print(f"Pipe: {pipe.pipe_length/1000:.1f} km x {pipe.pipe_diameter*100:.0f} cm")
    print(f"Material: Steel (roughness = {pipe.roughness:.0e} m)")
    
    # steady_state expects [P_inlet, T_inlet, flow_rate]
    inlet_pressures = np.array([200000, 300000, 400000, 500000])  # Pa
    inlet_temperature = 293.15  # K (20°C)
    flow_rate = 0.05  # m³/s
    
    print(f"\nSteady-State Analysis for {flow_rate:.3f} m³/s:")
    print("Inlet P | Outlet P | Pressure Drop | Velocity | Reynolds")
    print("(kPa)   | (kPa)    | (kPa)         | (m/s)    | Number")
    print("-" * 60)
    
    pipe_results = []
    for p_in in inlet_pressures:
        inputs = np.array([p_in, inlet_temperature, flow_rate])
        result = pipe.steady_state(inputs)
        
        p_out = result[0]
        t_out = result[1]
        
        # Calculate velocity and Reynolds number for display
        velocity = flow_rate / (np.pi * (pipe.pipe_diameter/2)**2)
        reynolds = pipe.fluid_density * velocity * pipe.pipe_diameter / pipe.fluid_viscosity
        pressure_drop = p_in - p_out
        
        print(f"{p_in/1000:7.0f} | {p_out/1000:8.0f} | {pressure_drop/1000:12.0f}  | {velocity:7.2f}  | {reynolds:8.0f}")
        
        pipe_results.append({
            'p_in': p_in, 'p_out': p_out, 'velocity': velocity, 'reynolds': reynolds
        })
    
    # Example 2: PeristalticFlow steady_state
    print("\n\nEXAMPLE 2: PeristalticFlow steady_state Function")
    print("-" * 50)
    
    pump = PeristalticFlow(
        tube_diameter=0.01,      # 10 mm tube
        tube_length=0.5,         # 50 cm in pump head
        pump_speed=100.0,        # 100 RPM
        occlusion_factor=0.9,    # 90% occlusion
        fluid_density=1000.0,    # Water
        name="SteadyStatePump"
    )
    
    print(f"Model: {pump.name}")
    print(f"Tube: {pump.tube_diameter*1000:.0f} mm ID x {pump.tube_length*100:.0f} cm")
    print(f"Speed: {pump.pump_speed:.0f} RPM, Occlusion: {pump.occlusion_factor*100:.0f}%")
    
    # steady_state expects [P_inlet, pump_speed, occlusion_level]
    pump_speeds = np.array([50, 75, 100, 125, 150])  # RPM
    inlet_pressure = 101325.0  # Atmospheric
    occlusion_level = 1.0  # Full occlusion
    
    print(f"\nSteady-State Analysis at {inlet_pressure/1000:.0f} kPa inlet:")
    print("Speed | Flow Rate | Outlet P | Backpressure")
    print("(RPM) | (mL/min)  | (kPa)    | Effect")
    print("-" * 40)
    
    pump_results = []

The comprehensive example demonstrates:

• PipeFlow Analysis: Pressure drop calculations for clean fluids

• PeristalticFlow Mapping: Speed-flow relationships for precision dosing

• SlurryPipeline Assessment: Multiphase flow with particle effects

• Comparative Performance: Model selection guidelines

Example Output

Key output sections include:

• PipeFlow pressure drop and Reynolds number analysis

• PeristalticFlow speed calibration and backpressure effects

• SlurryPipeline concentration changes and settling effects

• Model comparison table with input/output formats

Model Selection Guidelines

Use PipeFlow for:

• Single-phase liquid transport

• Long-distance pipeline systems

• High-pressure applications

• Temperature-sensitive processes

Use PeristalticFlow for:

• Precise fluid dosing

• Chemical compatibility requirements

• Low-flow rate applications

• Analytical instrumentation

Use SlurryPipeline for:

• Solid-liquid transport

• Mining and dredging applications

• Particle suspension systems

• Concentration-critical processes

Performance Comparison

Model Performance Characteristics

Characteristic	PipeFlow	PeristalticFlow	SlurryPipeline
Accuracy	±2-5%	±1-3%	±5-10%
Pressure Range	0-100 bar	0-10 bar	0-50 bar
Flow Range	0.001-10 m³/s	0.1-1000 mL/min	0.01-5 m³/s
Application	General purpose	Precision dosing	Multiphase transport

Visualization

The steady-state analysis generates comprehensive visualization including:

1. Pressure Drop Comparison: Clean vs slurry flow pressure losses

2. Reynolds Number Analysis: Flow regime identification

3. Flow Rate Relationships: Model-specific performance curves

4. Model Characteristics: Complexity vs application scope comparison

Applications

The steady_state function is used for:

• Process Design: Equipment sizing and selection

• System Optimization: Operating point determination

• Model Validation: Experimental data comparison

• Sensitivity Analysis: Parameter effect assessment

• Performance Mapping: Operating envelope definition

Computational Aspects

Solution Methods:

• Direct Calculation: Explicit algebraic solutions where possible

• Iterative Methods: Newton-Raphson for implicit equations

• Convergence Criteria: Relative tolerance of 1e-6

• Robustness: Bounds checking and physical constraints

Performance Metrics:

• Computation Time: < 1 ms per evaluation (typical)

• Memory Usage: Minimal state storage requirements

• Numerical Stability: Validated across operating ranges

• Error Handling: Graceful degradation for edge cases

Technical Implementation

The steady-state function implements:

def steady_state(model, inputs):
    """
    Calculate steady-state solution for transport model

    Parameters:
    -----------
    model : TransportModel
        Transport model instance (PipeFlow, PeristalticFlow, SlurryPipeline)
    inputs : array_like
        Model-specific input vector

    Returns:
    --------
    outputs : array_like
        Model-specific output vector
    """

    # Validate inputs
    inputs = validate_inputs(model, inputs)

    # Calculate steady-state solution
    outputs = model.steady_state(inputs)

    # Validate outputs
    outputs = validate_outputs(model, outputs)

    return outputs

Best Practices

Input Validation:

• Check physical bounds (positive pressures, flows)

• Verify units and dimensional consistency

• Handle edge cases (zero flow, extreme conditions)

Output Analysis:

• Compare results across models when applicable

• Validate against known analytical solutions

• Check conservation principles (mass, energy)

Error Handling:

• Provide meaningful error messages

• Implement fallback calculations

• Log convergence issues for debugging

Technical References

1. Bird, R.B., Stewart, W.E. & Lightfoot, E.N. (2007). Transport Phenomena, 2nd Edition. John Wiley & Sons.

2. Welty, J.R. et al. (2007). Fundamentals of Momentum, Heat, and Mass Transfer, 5th Edition. John Wiley & Sons.

3. McCabe, W.L., Smith, J.C. & Harriott, P. (2004). Unit Operations of Chemical Engineering, 7th Edition. McGraw-Hill.

4. Perry, R.H. & Green, D.W. (2007). Perry’s Chemical Engineers’ Handbook, 8th Edition. McGraw-Hill.

See Also

• PipeFlow Class - Pipeline transport modeling

• PeristalticFlow Class - Peristaltic pump modeling

• SlurryPipeline Class - Multiphase slurry transport

• dynamics Function - Dynamic modeling functions