Transport Continuous Liquid Module

The Transport Continuous Liquid module provides comprehensive modeling capabilities for fluid transport systems in process control applications. This module includes three specialized transport models and supporting analysis functions for steady-state and dynamic analysis.

Transport Models:

Analysis Functions:

Overview

The module implements physics-based models for three distinct categories of liquid transport systems:

  1. Single-Phase Pipeline Transport (PipeFlow Class) - Clean liquid transport through pipelines

  2. Positive Displacement Pumping (PeristalticFlow Class) - Precision fluid metering and dosing

  3. Multiphase Slurry Transport (SlurryPipeline Class) - Solid-liquid mixture transport

Each model provides both steady_state Function and dynamics Function analysis capabilities for comprehensive system characterization.

Quick Start

Basic Usage Example

from transport.continuous.liquid import PipeFlow, PeristalticFlow, SlurryPipeline
import numpy as np

# Pipeline Transport
pipe = PipeFlow(pipe_length=1000, pipe_diameter=0.2)
result = pipe.steady_state([300000, 293.15, 0.05])  # [P_in, T_in, Q]

# Peristaltic Pumping
pump = PeristalticFlow(tube_diameter=0.01, pump_speed=100)
result = pump.steady_state([101325, 100, 1.0])  # [P_in, speed, occlusion]

# Slurry Transport
slurry = SlurryPipeline(solid_concentration=0.3, particle_diameter=150e-6)
result = slurry.steady_state([500000, 0.2, 0.3])  # [P_in, Q, C_solid]

Model Selection Guide

Transport Model Selection

Application

Model

Key Features

Typical Range

Pipeline Systems

PipeFlow Class

Pressure drop, thermal effects

0.001-10 m³/s

Precision Dosing

PeristalticFlow Class

Accurate metering, pulsation

0.1-1000 mL/min

Slurry Transport

SlurryPipeline Class

Particle suspension, settling

0.01-5 m³/s

Features

Comprehensive Modeling:

  • Physics-based mathematical models

  • Validated against experimental data

  • Industry-standard correlations and equations

  • Consistent API across all models

Analysis Capabilities:

  • Steady-state design point calculations

  • Dynamic response and transient analysis

  • Parameter sensitivity studies

  • Performance optimization

Engineering Applications:

  • Process design and equipment sizing

  • Control system development

  • Operational troubleshooting

  • Performance monitoring and optimization

Documentation and Examples:

  • Complete API documentation

  • Real-world application examples

  • Comprehensive visualization

  • Integration with Sphinx documentation

Module Structure

transport/continuous/liquid/
├── PipeFlow.py              # Pipeline transport model
├── PeristalticFlow.py       # Peristaltic pump model
├── SlurryPipeline.py        # Slurry transport model
├── __init__.py              # Module initialization
├── examples/                # Usage examples
│   ├── PipeFlow_example.py
│   ├── PeristalticFlow_example.py
│   ├── SlurryPipeline_example.py
│   ├── steady_state_example.py
│   └── dynamics_example.py
├── outputs/                 # Example outputs
│   ├── *.out               # Text outputs
│   └── *.png               # Visualization plots
└── docs/                   # Documentation
    ├── *.rst               # Sphinx documentation
    └── *.md                # Technical documentation

Installation

The module requires the following dependencies:

pip install numpy scipy matplotlib

Import the module components:

from transport.continuous.liquid import (
    PipeFlow,
    PeristalticFlow,
    SlurryPipeline
)

API Reference

Common Interface:

All transport models implement a consistent interface:

class TransportModel:
    def __init__(self, **parameters):
        """Initialize model with physical parameters"""

    def steady_state(self, inputs):
        """Calculate steady-state solution"""

    def dynamics(self, t, x, u):
        """Calculate time derivatives for dynamic analysis"""

    def describe(self):
        """Return model metadata and documentation"""

Input/Output Conventions:

  • Units: SI units throughout (Pa, m³/s, K, kg/m³)

  • Arrays: NumPy arrays for vector inputs/outputs

  • Validation: Automatic input validation and bounds checking

  • Documentation: Built-in introspection and help system

Performance and Validation

Computational Performance:

  • Optimized for real-time applications

  • Vectorized operations for efficiency

  • Minimal memory footprint

  • Sub-millisecond execution times

Model Validation:

  • Compared against experimental data

  • Validated with analytical solutions

  • Cross-checked with commercial software

  • Peer-reviewed implementations

Quality Assurance:

  • Comprehensive unit testing

  • Continuous integration testing

  • Code coverage analysis

  • Documentation testing

Contributing

The module follows standard Python development practices:

  • Code Style: PEP 8 compliance

  • Documentation: NumPy docstring format

  • Testing: pytest framework

  • Version Control: Git with semantic versioning

License and Citation

This module is part of the SPROCLIB (Standard Process Control Library) project.

Citation:

If you use this module in academic work, please cite:

SPROCLIB Transport Module (2025). "Continuous Liquid Transport Models
for Process Control Applications." Standard Process Control Library.

References:

For detailed technical references, see the individual model documentation:

Indices and Tables