AI-Driven Microfluidic Plasma Separator & Deep Learning Surrogate Optimizer (Part 2)

An end-to-end computational framework and interactive web suite for designing, simulating, and optimizing Four-Stage Passive Microfluidic Blood Cell Filters using Deterministic Lateral Displacement (DLD) and Deep Learning Surrogate Models.

By replacing hours of computationally expensive Navier-Stokes Computational Fluid Dynamics (CFD) simulations with sub-millisecond neural surrogate inference, this system performs multi-objective design space exploration to yield purified plasma and enriched cellular hematocrit fractions for downstream disease screening pipelines.

---

🔬 Scientific Overview

Blood plasma separation is a foundational step in point-of-care diagnostics (POCT) and personalized medicine. Passive microfluidic devices filter red blood cells (RBCs), white blood cells (WBCs), and platelets from whole blood without external pumps or centrifuges by exploiting micro-hydrodynamic phenomena such as the Zweifach-Kung effect, hydrodynamic filtration, and Deterministic Lateral Displacement (DLD).

                  ┌───────────────────────────────────────────────────────────┐
                  │                 4-Stage Microfluidic DLD                  │
   Whole Blood    │ ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐     │    Purified Plasma
   ===========>   │ │ Stage 1 │==>│ Stage 2 │==>│ Stage 3 │==>│ Stage 4 │===> =================>
    (20 mL)       │ └─────────┘   └─────────┘   └─────────┘   └─────────┘     │     (Sub-2 Min)
                  └─────────────────────┬─────────────────────────────────────┘
                                        │
                                        ▼ Enriched Hematocrit
                             ┌─────────────────────┐
                             │ Diagnostic Screening│
                             └─────────────────────┘

The Part 2 Advancement

While traditional microfluidic optimization requires full 3D CAD modeling and iterative finite-volume meshing in OpenFOAM (taking 4–12 hours per evaluation), Part 2 introduces:

1. Real CFD Training Data Integration: Replaces synthetic/mock physics models with OpenFOAM CFD velocity fields and particle trajectory datasets.
2. Four-Stage DLD Architecture: Features multi-tiered pillar arrays with progressive pillar diameters, row offsets ($\Delta \lambda$), and critical cutoff sizes ($D_c$).
3. Sub-2-Minute Whole Blood Processing: Achieves 84.74% plasma purity and 72.67% plasma recovery for a 20 mL sample in under two minutes.
4. Dual Diagnostic Pipeline:
   • Cellular Hematocrit Fraction: Direct feed into diagnostic ML models for predicting anemia, sickle cell disease, leukemia, and malaria.
   • Purified Plasma Fraction: Direct feed into proteomic and pharmacokinetic profiling models for drug dosage determination across 7 target conditions.

---

🛠️ System Architecture

graph TD
    subgraph Client Suite [React 19 Interactive Dashboard]
        UI[Interactive 2D/3D Visualizer]
        OptEngine[Client-Side Surrogate & Random Search]
        Gemini[Gemini AI Engineering Rationale]
        PerfCharts[Recharts Performance Analytics]
    end

    subgraph Machine Learning Pipeline [Surrogate Trainer]
        Notebook[Jupyter Optimization Notebook]
        Optuna[Optuna Hyperparameter Tuner]
        SurrModel[XGBoost / LightGBM / Neural Net]
    end

    subgraph Data & Physical Verification [CFD Engine]
        OpenFOAM[OpenFOAM Multi-Phase CFD Solvers]
        Datasets[CSV Feature Datasets]
        Plots[Flow & Mesh Field Snapshots]
    end

    UI -->|Adjust Parameters| OptEngine
    OptEngine -->|Sub-ms Predictions| UI
    UI -->|Telemetry & Metrics| Gemini
    Gemini -->|Physics Rationale| UI
    
    OpenFOAM -->|CFD Simulation Data| Datasets
    Datasets -->|Train & Validate| Notebook
    Notebook -->|Hyperparameter Search| Optuna
    Optuna -->|Optimal Weights| SurrModel
    SurrModel -->|Model Exports| OptEngine

Loading

---

📂 Repository Structure

microfluidic_device_part_2/
├── .gitignore                   # Excludes manuscripts, binaries, and temporary files
├── LICENSE                      # MIT License (Freely available contribution license)
├── README.md                    # Project documentation
├── requirements.txt             # Python machine learning & data science dependencies
├── data/                        # OpenFOAM CFD datasets & surrogate training metrics
│   ├── comprehensive_field_dataset.csv
│   ├── microfluidics_field_dataset.csv
│   └── plasma_ml_dataset.csv
├── designer/                    # Web Application (React 19 + TypeScript + Vite 6)
│   ├── index.html               # Main entry HTML
│   ├── package.json             # NPM dependencies & scripts
│   ├── tsconfig.json            # TypeScript configuration
│   ├── vite.config.ts           # Vite build configuration
│   ├── App.tsx                  # Dashboard layout & state orchestrator
│   ├── types.ts                 # Type definitions for geometry & surrogate metrics
│   ├── components/              # UI Components
│   │   ├── DeviceVisualizer.tsx # Canvas/SVG microfluidic pillar geometry renderer
│   │   ├── GeminiAnalysis.tsx   # AI-driven physics rationale & diagnostic agent
│   │   ├── InteractiveSimulation.tsx # Dynamic fluid flow & particle trajectory simulator
│   │   ├── OptimizerControl.tsx # Multi-parameter slider & search control panel
│   │   ├── PerformanceCharts.tsx # Purity, recovery, and pressure drop visualization
│   │   ├── ResultsDisplay.tsx   # Optimization summary metrics & diagnostic panel
│   │   └── common/              # Shared UI components
│   └── services/                # Application Services
│       ├── geminiService.ts     # Google Gemini API integration for physics reasoning
│       └── optimizationService.ts # Client-side surrogate modeling & search algorithms
├── docs/                        # Project visual documentation & schematics
│   ├── flowcharts/              # Flowcharts detailing 4-stage DLD pipeline & ML workflow
│   └── simulations/             # OpenFOAM CFD velocity fields & pillar displacement plots
└── notebooks/                   # Jupyter Notebooks
    └── ml_surrogate_optimization.ipynb # Model training, Optuna tuning, and evaluation

Note: Scientific manuscript PDFs and LaTeX source drafts are intentionally excluded from this source distribution to maintain a clean, code-focused repository.

---

🧮 Mathematical & Physical Principles

1. Deterministic Lateral Displacement (DLD) Critical Diameter ($D_c$)

In a pillar array with pillar gap $G$, pillar diameter $D_p$, and row shift angle $\theta = \arctan(\Delta \lambda / \lambda)$, the critical particle diameter separating displacement mode from zigzag mode is given by:

$$D_c = 3 \cdot \Delta u \cdot G = 2 \cdot G \cdot \varepsilon \cdot \eta$$

where $\varepsilon$ is the shift fraction and $\eta$ is the non-uniform flow distribution factor between adjacent pillars.

2. Multi-Objective Fitness Score

The optimization engine evaluates design candidates across 3,000 iterations using the multi-objective objective function:

$$\text{Fitness} = w_1 \cdot \text{Purity} + w_2 \cdot \text{Recovery} - w_3 \cdot \left(\frac{\Delta P}{\Delta P_{\text{max}}}\right)$$

• $w_1 = 0.50$ (Plasma Purity weight)
• $w_2 = 0.30$ (Plasma Recovery weight)
• $w_3 = 0.20$ (Normalized Pressure Drop penalty)

---

📊 Benchmark Results

Parameter / Metric	Initial Design (Part 1 Base)	Optimized 4-Stage DLD (Part 2)	Unit
Separation Stages	1 Stage	4 Progressive Stages	-
Pillar Diameter ($D_p$)	$50.0 \ \mu\text{m}$	$25.0 - 45.0 \ \mu\text{m}$	$\mu\text{m}$
Channel Width ($W$)	$300 \ \mu\text{m}$	$450 \ \mu\text{m}$	$\mu\text{m}$
Plasma Purity	76.2%	84.74%	%
Plasma Recovery	61.5%	72.67%	%
Processed Volume	5 mL	20.0 mL	mL
Processing Time	12.5 min	< 1.95 min	min
Pressure Drop ($\Delta P$)	$14.2 \ \text{kPa}$	$8.4 \ \text{kPa}$	kPa
Evaluation Time	4.5 hours (CFD)	0.82 ms (Surrogate)	per run

---

📋 Prerequisites

Ensure your system meets the following prerequisites before running the project:

• Python: v3.10 or higher
• Node.js: v18.0.0 or higher
• npm: v9.0.0 or higher
• Jupyter Notebook / JupyterLab

---

🚀 Quick Start & Installation

1. Python ML Surrogate Pipeline

# 1. Clone the repository
git clone https://github.com/Runtime-Slayers/ai-microfluidic-plasma-separator.git
cd ai-microfluidic-plasma-separator

# 2. Create and activate a virtual environment
python3 -m venv venv
source venv/bin/activate   # On Windows use: venv\Scripts\activate

# 3. Install required Python packages
pip install -r requirements.txt

# 4. Launch Jupyter Notebook
jupyter notebook notebooks/ml_surrogate_optimization.ipynb

2. Interactive Web Designer Application

# Navigate to the web application folder
cd designer

# Install NPM packages
npm install

# (Optional) Create .env.local to enable Gemini AI Rationale Engine
echo "VITE_GEMINI_API_KEY=your_api_key_here" > .env.local

# Launch local development server
npm run dev

Open your browser and navigate to http://localhost:5173.

---

🏥 Dual Computational Diagnostic Pipeline

The microfluidic device separates whole blood into two streams:

1. Hematocrit Fraction Channel:
   • Evaluates RBC morphology, cell counts, and deformation.
   • Screened Diseases: Anemia, Sickle Cell Disease, Leukemia, Malaria.
2. Purified Plasma Fraction Channel:
   • Evaluates protein concentrations, enzymatic assays, and metabolic markers.
   • Screened Diseases: Chronic Kidney Disease (CKD), Sepsis, Cardiac Disease / Troponin-I, Diabetes Mellitus.
   • Pharmacokinetic & Pharmacodynamic dosing recommendation models.

---

📄 License & Contribution Guidelines

This repository is released under the MIT License, making it freely available for academic research, industrial prototyping, and open-source contributions.

Contributing

Contributions are welcomed! Suggested areas for contribution:

• Additional OpenFOAM mesh geometries and particle transport CFD solver scripts.
• Deep Learning model architectures (e.g., Graph Neural Networks / Physics-Informed Neural Networks).
• UI component extensions in the React application (designer/).

To contribute:

1. Fork the Repository.
2. Create a feature branch (git checkout -b feature/AmazingFeature).
3. Commit your changes (git commit -m 'Add AmazingFeature').
4. Push to the branch (git push origin feature/AmazingFeature).
5. Open a Pull Request.

---

👤 Authors & Acknowledgments

• Bhavanam Rajendra
• Boddu Saran (saran.boddu777@gmail.com)
• Muthu Raman Ramanathan
• Palakurthi K S S S S Srihari Likith

Amrita School of Artificial Intelligence, Coimbatore
Amrita Vishwa Vidyapeetham, India