Feat: Project Deployment on huggingface spaces

.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

README.md

@@ -11,4 +11,90 @@ license: mit
 short_description: This project demonstrates the use of Linear Programming (PL)
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<h1 align="center">Operations Research Web Application</h1>
+
+<p align="center">
+  <img src="https://insat.rnu.tn/assets/images/logo_c.png" width="100" alt="INSAT Logo"><br><br>
+  <a href="https://kacemath-operations-research.hf.space/" target="_blank">
+    <img src="https://img.shields.io/badge/HuggingFace-Space-blue?logo=huggingface" alt="Try it on Hugging Face Spaces" />
+  </a>
+</p>
+
+This project demonstrates the use of **Linear Programming (PL)** and **Mixed-Integer Linear Programming (PLNE)** for solving real-world optimisation problems using **Gurobi**. It uses **Gradio** to provide an interactive web interface.
+
+## Features
+
+- **Production Planning (PL):** Optimises the number of products to manufacture for maximum profit under resource constraints.
+- **Staff Scheduling (PLNE):** Mock assignment of employees to shifts based on availability.
+
+## Project Structure
+
+```
+.
+├── app.py                          # Main entry point of the Gradio application
+├── assets/
+│   └── compte_rendu.pdf           # Project report
+├── models/
+│   └── gurobi_models.py           # Gurobi-based solvers for PL and PLNE
+├── ui/
+│   └── gradio_sections.py         # UI layout and Gradio component logic
+├── requirements.txt               # Python dependencies
+└── README.md                      # Project documentation
+````
+
+## Prerequisites
+- Python 3.9 or higher
+
+## Environment Setup
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/KacemMathlouthi/OperationsResearch.git
+cd OperationsResearch
+````
+
+### 2. Create and activate a virtual environment
+
+#### Linux/macOS
+
+```bash
+python3 -m venv venv
+source venv/bin/activate
+```
+
+#### Windows
+
+```cmd
+python -m venv venv
+venv\Scripts\activate
+```
+
+### 3. Install dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+## Running the Application
+
+Ensure you are in the project root directory and your virtual environment is activated:
+
+```bash
+python app.py
+```
+
+The application will launch locally at `http://127.0.0.1:7860/`.
+
+## Usage
+
+### Tabs Available:
+
+* **Project Info:** Displays team information and a PDF report.
+* **Production Planning (PL):** Solve and visualise a linear programming problem using product and resource data.
+* **Staff Scheduling (PLNE):** Simulated assignment of employees to shifts based on availability.
+
+## Notes
+
+* Visualisations are generated with `matplotlib`.
+* UI built with `Gradio Blocks` using tabbed layout.
+* PDF report embedded with base64 encoding.

achref/README.md

@@ -0,0 +1,60 @@
+# Satellite Collision Avoidance Web App
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A web-based interface for optimizing satellite trajectories to prevent collisions while minimizing fuel consumption and deviation from uncorrected paths. Built with Python/Gurobi for optimization and Three.js for 3D visualization.
+
+![App Screenshot](./assets/satellite_trajectories.gif)
+
+### Optimization Objective
+
+We now jointly minimize fuel usage and trajectory deviation from the nominal (no-thrust) path:
+
+```math
+\text{Minimize } \sum_{i=1}^N \sum_{t=0}^{T-1} \delta_{i,t}
+\;+
+\;\lambda \sum_{i=1}^N \sum_{t=0}^{T} \sum_{a\in\{x,y,z\}} d_{i,t}^a
+```
+
+where:
+
+* \$\delta\_{i,t} \ge c\_{\text{fuel}}\sum\_{a\in{x,y,z}} |u\_{i,t}^a|\$ (fuel proxy)
+* \$d\_{i,t}^a \ge |p\_{i,t}^a - p\_{i,t}^{a,\mathrm{nom}}|\$ (deviation from nominal trajectory)
+* \$\lambda\$ is an optional weight balancing fuel vs. deviation (default \$\lambda=1\$).
+
+### Features
+
+* Interactive 3D visualization of satellite trajectories
+* Configurable safety margins, thrust limits, and deviation weight
+* Real-time MILP optimization backend
+* Scenario export/import in JSON format
+
+## Problem Formulation
+
+### Orbital Dynamics
+
+For satellite \$i\$ at time \$t\$ with mass \$m\_i\$ and thrust \$\mathbf{u}\_{i,t}\$:
+
+```math
+\begin{aligned}
+\mathbf{p}_{i,t+1} &= \mathbf{p}_{i,t} + \mathbf{v}_{i,t} \Delta t + \frac{1}{2m_i} \mathbf{u}_{i,t} (\Delta t)^2 \\
+\mathbf{v}_{i,t+1} &= \mathbf{v}_{i,t} + \frac{1}{m_i} \mathbf{u}_{i,t} \Delta t
+\end{aligned}
+```
+
+### Collision Avoidance
+
+For all satellite pairs \$(i,j)\$ and times \$t \ge 1\$:
+
+```math
+\begin{aligned}
+|p_{i,t}^x - p_{j,t}^x| &\ge d_{\text{safe}} \cdot b_{ij,t}^x \\
+|p_{i,t}^y - p_{j,t}^y| &\ge d_{\text{safe}} \cdot b_{ij,t}^y \\
+|p_{i,t}^z - p_{j,t}^z| &\ge d_{\text{safe}} \cdot b_{ij,t}^z \\
+ b_{ij,t}^x + b_{ij,t}^y + b_{ij,t}^z &\ge 1 \quad (b_{ij,t}^a \in \{0,1\})
+\end{aligned}
+```
+
+### Additional Resources
+
+For a comprehensive explanation of the problem statement, including mathematical formulations and assumptions, refer to the [Problem Statement](./assets/problem_statement.md). This document provides in-depth details about the orbital dynamics, collision avoidance constraints, and optimization objectives used in this project.

achref/infeasible.ilp

@@ -0,0 +1,36 @@
+\ Model SatelliteLP_WithTracking_copy
+\ LP format - for model browsing. Use MPS format to capture full model detail.
+Minimize
+ 
+Subject To
+ init_p_Sat1_1: p_Sat1_0[1] = 0
+ init_v_Sat1_1: v_Sat1_0[1] = 0
+ dyn_p_Sat1_0_1: - 0.0005 u_Sat1_0[1] - p_Sat1_0[1] + p_Sat1_1[1]
+   - 0.1 v_Sat1_0[1] = 0
+ dyn_v_Sat1_0_1: - 0.01 u_Sat1_0[1] - v_Sat1_0[1] + v_Sat1_1[1] = 0
+ dyn_p_Sat1_1_1: - 0.0005 u_Sat1_1[1] - p_Sat1_1[1] + p_Sat1_2[1]
+   - 0.1 v_Sat1_1[1] = 0
+ init_p_Sat2_1: p_Sat2_0[1] = 1.732051
+ init_v_Sat2_1: v_Sat2_0[1] = -0.0866025
+ dyn_p_Sat2_0_1: - 0.0005 u_Sat2_0[1] - p_Sat2_0[1] + p_Sat2_1[1]
+   - 0.1 v_Sat2_0[1] = 0
+ dyn_v_Sat2_0_1: - 0.01 u_Sat2_0[1] - v_Sat2_0[1] + v_Sat2_1[1] = 0
+ dyn_p_Sat2_1_1: - 0.0005 u_Sat2_1[1] - p_Sat2_1[1] + p_Sat2_2[1]
+   - 0.1 v_Sat2_1[1] = 0
+ con_dy_Sat1_Sat2_2: - p_Sat1_2[1] + p_Sat2_2[1] + dy_Sat1_Sat2_2 = 0
+Bounds
+ -infinity <= u_Sat1_0[1] <= 100
+ -infinity <= u_Sat1_1[1] <= 100
+ u_Sat2_0[1] >= -100
+ u_Sat2_1[1] >= -100
+ p_Sat1_0[1] free
+ p_Sat1_1[1] free
+ p_Sat1_2[1] free
+ v_Sat1_0[1] free
+ v_Sat1_1[1] free
+ p_Sat2_0[1] free
+ p_Sat2_1[1] free
+ p_Sat2_2[1] free
+ v_Sat2_0[1] free
+ v_Sat2_1[1] free
+End

achref/src/config/__init__.py

@@ -0,0 +1 @@
+from .config import get_settings

achref/src/config/config.py

@@ -0,0 +1,39 @@
+import os
+from functools import lru_cache
+from pydantic_settings import BaseSettings
+from dotenv import load_dotenv
+
+load_dotenv(".env")
+
+class Settings(BaseSettings):
+    """
+    Settings class for this application.
+    Utilizes the BaseSettings from Pydantic for environment variables.
+    """
+    # Python setup
+    PYTHONPATH: str = None
+
+    class Config:
+        env_file = ".env"
+        extra = "ignore"
+        
+        
+@lru_cache(maxsize=None)
+def get_settings() -> Settings:
+    """
+    Function to get and cache settings.
+    The settings are cached to avoid repeated disk I/O.
+    """
+    environment = os.getenv("ENVIRONMENT", "local")
+
+    if environment == "local":
+        settings_file = ".env"
+    elif environment == "dev":
+        settings_file = ".env.dev"
+    elif environment == "prod":
+        settings_file = ".env.prod"
+    else:
+        raise ValueError(f"Invalid environment: {environment}")
+
+    # Load settings from the respective .env file
+    return Settings(_env_file=settings_file)  # type: ignore

achref/src/logger/__init__.py

@@ -0,0 +1 @@
+from .logger import get_logger

achref/src/logger/logger.py

@@ -0,0 +1,106 @@
+import functools
+import logging
+import sys
+import os
+from dotenv import load_dotenv
+from uvicorn.logging import ColourizedFormatter
+from typing import Any, Callable
+
+load_dotenv()
+
+
+
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+
+# Mapping of string levels to logging constants
+LOG_LEVEL_MAPPING = {
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL
+}
+
+# Set the actual logging level
+LOG_LEVEL = LOG_LEVEL_MAPPING.get(LOG_LEVEL, logging.INFO)  # Default to INFO if invalid
+
+# Custom colorized formatter to apply colors specifically to log levels
+class CustomColourizedFormatter(ColourizedFormatter):
+    def format(self, record: logging.LogRecord) -> str:
+        # Define color mappings for different log levels
+        level_color_map = {
+            "DEBUG": "\033[34m",    # Blue
+            "INFO": "\033[32m",     # Green
+            "WARNING": "\033[33m",  # Yellow
+            "ERROR": "\033[31m",    # Red
+            "CRITICAL": "\033[41m", # Red background
+        }
+
+        # Reset color
+        reset = "\033[0m"
+
+        # Apply color to the log level name
+        record.levelname = f"{level_color_map.get(record.levelname, '')}{record.levelname}{reset}"
+
+        # Format the log message using the parent class's format method
+        return super().format(record)
+
+def get_logger(name: str) -> logging.Logger:
+    """Creates a logger object that reads its log level from .env.
+
+    Args:
+        name (str): name given to the logger
+
+    Returns:
+        logging.Logger: logger object to be used for logging 
+    """
+    # Create logger
+    logger = logging.getLogger(name)
+    logger.setLevel(LOG_LEVEL)  # Set level based on .env file
+
+    # Prevent adding multiple handlers if already exists
+    if not logger.hasHandlers():
+        # Create console handler
+        ch = logging.StreamHandler(sys.stdout)
+        ch.setLevel(LOG_LEVEL)  # Set handler level
+
+        # Create a custom formatter with colored log levels
+        formatter = CustomColourizedFormatter(
+            "{asctime} | {levelname:<8} | {message}",
+            style="{",
+            datefmt="%Y-%m-%d %H:%M:%S",
+            use_colors=True
+        )
+
+        # Add formatter to the handler
+        ch.setFormatter(formatter)
+
+        # Add handler to the logger
+        logger.addHandler(ch)
+
+    return logger
+
+# Logger decorator implementation
+def log_function_call(logger: logging.Logger) -> Callable:
+    """A decorator that logs the function calls and results.
+
+    Args:
+        logger (logging.Logger): The logger instance to use for logging.
+    
+    Returns:
+        Callable: A wrapper function that logs the execution details.
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            # Log the function call with arguments
+            logger.debug(f"Calling {func.__name__} with args: {args} and kwargs: {kwargs}")
+            result = func(*args, **kwargs)
+            # Log the function result
+            logger.debug(f"{func.__name__} returned {result}")
+            return result
+        return wrapper
+    return decorator
+
+
+logger = logging.getLogger(__name__)

achref/src/models/gorubi_models.py

@@ -0,0 +1,255 @@
+import gurobipy as gp
+from gurobipy import GRB
+from itertools import combinations
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import re
+import matplotlib.animation as animation
+
+def animate_satellite_trajectories(model, time_steps, interval=200):
+    """
+    Creates a 3D animated plot of satellite trajectories and thrust vectors.
+
+    Args:
+        model (gp.Model): Solved Gurobi model containing:
+            - position variables named `p_{sat}_{t}[coord]`
+            - thrust variables named `u_{sat}_{t}[coord]`
+        time_steps (list of int): List of time step indices used in the optimization.
+        interval (int): Delay between frames in milliseconds.
+    """
+    # Extract data containers
+    positions = {}
+    thrusts = {}
+    # Patterns to match variable names
+    p_pattern = re.compile(r'p_(\w+)_(\d+)\[(\d+)\]')
+    u_pattern = re.compile(r'u_(\w+)_(\d+)\[(\d+)\]')
+
+    # Populate positions and thrusts dictionaries
+    for var in model.getVars():
+        # Position variables
+        pm = p_pattern.match(var.VarName)
+        if pm:
+            sat, t_str, coord_str = pm.groups()
+            t = int(t_str)
+            coord = int(coord_str)
+            positions.setdefault(sat, {}).setdefault(t, [0.0, 0.0, 0.0])[coord] = var.Xn
+            continue
+        # Thrust variables
+        um = u_pattern.match(var.VarName)
+        if um:
+            sat, t_str, coord_str = um.groups()
+            t = int(t_str)
+            coord = int(coord_str)
+            thrusts.setdefault(sat, {}).setdefault(t, [0.0, 0.0, 0.0])[coord] = var.Xn
+
+    sats = sorted(positions.keys())
+
+    # Prepare 3D figure
+    fig = plt.figure(figsize=(10, 8))
+    ax = fig.add_subplot(111, projection='3d')
+    ax.set_xlabel('X (m)')
+    ax.set_ylabel('Y (m)')
+    ax.set_zlabel('Z (m)')
+    ax.set_title('Satellite Trajectories and Thrust Animation')
+
+    # Plot objects for trajectories, end markers, and quivers
+    traj_lines = {sat: ax.plot([], [], [], label=f'{sat} traj')[0] for sat in sats}
+    end_markers = {sat: ax.plot([], [], [], marker='o', linestyle='')[0] for sat in sats}
+    quiver_objs = {sat: None for sat in sats}
+
+    # Set axis limits based on all positions
+    all_x = [positions[s][t][0] for s in sats for t in positions[s]]
+    all_y = [positions[s][t][1] for s in sats for t in positions[s]]
+    all_z = [positions[s][t][2] for s in sats for t in positions[s]]
+    ax.set_xlim(min(all_x), max(all_x))
+    ax.set_ylim(min(all_y), max(all_y))
+    ax.set_zlim(min(all_z), max(all_z))
+    ax.legend()
+
+    def update(frame):
+        # Remove previous quivers
+        for sat in sats:
+            if quiver_objs[sat] is not None:
+                quiver_objs[sat].remove()
+
+        # Update each satellite's trajectory, marker, and thrust arrow
+        for sat in sats:
+            # Trajectory up to current frame
+            xs = [positions[sat][t][0] for t in time_steps if t <= frame]
+            ys = [positions[sat][t][1] for t in time_steps if t <= frame]
+            zs = [positions[sat][t][2] for t in time_steps if t <= frame]
+            traj_lines[sat].set_data(xs, ys)
+            traj_lines[sat].set_3d_properties(zs)
+
+            # End marker at last position
+            if xs:
+                end_markers[sat].set_data([xs[-1]], [ys[-1]])
+                end_markers[sat].set_3d_properties([zs[-1]])
+
+            # Thrust arrow at this frame
+            ux, uy, uz = thrusts.get(sat, {}).get(frame, [0.0, 0.0, 0.0])
+            # Draw new quiver
+            quiver_objs[sat] = ax.quiver(
+                xs[-1], ys[-1], zs[-1], ux, uy, uz,
+                length=1e3, normalize=True
+            )
+
+        # Return artists to update
+        artists = list(traj_lines.values()) + list(end_markers.values())
+        artists += [q for q in quiver_objs.values() if q is not None]
+        return artists
+
+    # Create animation
+    ani = animation.FuncAnimation(
+        fig, update, frames=time_steps, interval=interval, blit=False
+    )
+    ani.save("satellite_trajectories.gif", writer='imagemagick', fps=5)
+    plt.show()
+# ---------------------------
+# SCALED DATA INITIALIZATION
+# ---------------------------
+# Units:
+#  • distance unit = 10 km
+#  • time unit = 10 s
+#  • velocity unit = 1 km/s
+#  • thrust unit = 1 kN
+#  • mass unit = 0.01 kg
+
+time_steps = list(range(20))
+dt = 10.0             # 10 s
+F_max = 10.0        # 100 kN
+c_fuel = 100     # same relative cost
+m_i = 1000.0           # 0.01 kg
+# safety distance scaled: 0.00001 units = 0.1 m
+# we apply collision avoidance only from t=1 onward to respect initial positions
+d_safe = 1
+
+initial_state = {
+    "Sat1": { "position": [20000/10000,     0.0,   0.0],   "velocity": [-100/1000,   0.0,    0.0] },
+    "Sat2": { "position": [-10000/10000, 17320.51/10000, 0.0], "velocity": [ 50/1000, -86.6025/1000, 0.0] },
+    "Sat3": { "position": [-10000/10000,-17320.51/10000, 0.0], "velocity": [ 50/1000,  86.6025/1000, 0.0] },
+}
+satellites = list(initial_state.keys())
+
+# ------------------------------------
+# PRECOMPUTE NOMINAL (UNCORRECTED) TRAJECTORIES
+# ------------------------------------
+# Nominal case: no thrust (u=0)
+nominal_positions = {sat: {0: initial_state[sat]['position'][:] } for sat in satellites}
+for sat in satellites:
+    pos = nominal_positions[sat]
+    vel = initial_state[sat]['velocity']
+    for t in time_steps[:-1]:
+        # constant velocity motion
+        next_pos = [pos[t][i] + vel[i] * dt for i in range(3)]
+        pos[t+1] = next_pos
+
+# ------------------------------------
+# ORBITAL DYNAMICS FUNCTION
+# ------------------------------------
+def add_orbital_dynamics(model, sat, time_steps, dt, mass, u, initial_pos, initial_vel):
+    p = {t: model.addVars(3, lb=-GRB.INFINITY, ub=GRB.INFINITY, name=f"p_{sat}_{t}") for t in time_steps}
+    v = {t: model.addVars(3, lb=-GRB.INFINITY, ub=GRB.INFINITY, name=f"v_{sat}_{t}") for t in time_steps}
+
+    # initial conditions
+    for coord in range(3):
+        model.addConstr(p[0][coord] == initial_pos[sat][coord], name=f"init_p_{sat}_{coord}")
+        model.addConstr(v[0][coord] == initial_vel[sat][coord], name=f"init_v_{sat}_{coord}")
+
+    # dynamics for t=0..T-1
+    for t in time_steps[:-1]:
+        for coord in range(3):
+            model.addConstr(
+                p[t+1][coord] == p[t][coord]
+                                 + v[t][coord] * dt
+                                 + 0.5 * (u[sat, t][coord] / mass) * dt * dt,
+                name=f"dyn_p_{sat}_{t}_{coord}"
+            )
+            model.addConstr(
+                v[t+1][coord] == v[t][coord]
+                                 + (u[sat, t][coord] / mass) * dt,
+                name=f"dyn_v_{sat}_{t}_{coord}"
+            )
+    return p, v
+
+# ---------------------------
+# BUILD & SOLVE WITH TRACKING PENALTY
+# ---------------------------
+
+def solve_lp_model():
+    model = gp.Model("SatelliteLP_WithTracking")
+
+    # decision vars: thrust u, fuel cost delta
+    u = {}
+    delta = {}
+    for sat in satellites:
+        for t in time_steps[:-1]:
+            u[sat, t] = model.addVars(3, lb=-F_max, ub=F_max, name=f"u_{sat}_{t}")
+            delta[sat, t] = model.addVar(lb=0.0, name=f"delta_{sat}_{t}")
+            for k in range(3):
+                abs_u = model.addVar(lb=0.0, name=f"abs_u_{sat}_{t}_{k}")
+                model.addGenConstrAbs(abs_u, u[sat, t][k], name=f"absConstr_{sat}_{t}_{k}")
+                model.addConstr(delta[sat, t] >= c_fuel * abs_u, name=f"fuelLink_{sat}_{t}_{k}")
+
+    # dynamics and collect position vars
+    initial_pos = {s: initial_state[s]["position"] for s in satellites}
+    initial_vel = {s: initial_state[s]["velocity"] for s in satellites}
+    positions = {}
+    for sat in satellites:
+        p, v = add_orbital_dynamics(model, sat, time_steps, dt, m_i, u, initial_pos, initial_vel)
+        positions[sat] = p
+
+    # collision avoidance as before
+    for t in time_steps[1:]:
+        for i, j in combinations(satellites, 2):
+            dx = model.addVar(name=f"dx_{i}_{j}_{t}")
+            dy = model.addVar(name=f"dy_{i}_{j}_{t}")
+            dz = model.addVar(name=f"dz_{i}_{j}_{t}")
+            model.addConstr(dx == positions[i][t][0] - positions[j][t][0], name=f"con_dx_{i}_{j}_{t}")
+            model.addConstr(dy == positions[i][t][1] - positions[j][t][1], name=f"con_dy_{i}_{j}_{t}")
+            model.addConstr(dz == positions[i][t][2] - positions[j][t][2], name=f"con_dz_{i}_{j}_{t}")
+            absx = model.addVar(lb=0.0, name=f"absx_{i}_{j}_{t}")
+            absy = model.addVar(lb=0.0, name=f"absy_{i}_{j}_{t}")
+            absz = model.addVar(lb=0.0, name=f"absz_{i}_{j}_{t}")
+            model.addGenConstrAbs(absx, dx, name=f"absxConstr_{i}_{j}_{t}")
+            model.addGenConstrAbs(absy, dy, name=f"absyConstr_{i}_{j}_{t}")
+            model.addGenConstrAbs(absz, dz, name=f"abszConstr_{i}_{j}_{t}")
+            bx = model.addVar(vtype=GRB.BINARY, name=f"bx_{i}_{j}_{t}")
+            by = model.addVar(vtype=GRB.BINARY, name=f"by_{i}_{j}_{t}")
+            bz = model.addVar(vtype=GRB.BINARY, name=f"bz_{i}_{j}_{t}")
+            model.addConstr(absx >= d_safe * bx, name=f"safe_x_{i}_{j}_{t}")
+            model.addConstr(absy >= d_safe * by, name=f"safe_y_{i}_{j}_{t}")
+            model.addConstr(absz >= d_safe * bz, name=f"safe_z_{i}_{j}_{t}")
+            model.addConstr(bx + by + bz >= 1, name=f"sep_sum_{i}_{j}_{t}")
+
+    # tracking penalty: absolute deviation from nominal
+    tracking_dev = {}
+    for sat in satellites:
+        for t in time_steps:
+            for coord in range(3):
+                dev = model.addVar(lb=0.0, name=f"dev_{sat}_{t}_{coord}")
+                tracking_dev[sat, t, coord] = dev
+                # deviation = p - p_nom
+                p_var = positions[sat][t][coord]
+                p_nom = nominal_positions[sat][t][coord]
+                # p_var - p_nom <= dev and -(p_var - p_nom) <= dev
+                model.addConstr(p_var - p_nom <= dev, name=f"dev_pos_{sat}_{t}_{coord}")
+                model.addConstr(p_nom - p_var <= dev, name=f"dev_neg_{sat}_{t}_{coord}")
+
+    # objective: fuel + tracking deviation
+    obj = gp.quicksum(delta[s, t] for s in satellites for t in time_steps[:-1]) \
+        + gp.quicksum(tracking_dev[s, t, c] for s in satellites for t in time_steps for c in range(3))
+    model.setObjective(obj, GRB.MINIMIZE)
+
+    # solve
+    model.optimize()
+    if model.status == GRB.INFEASIBLE:
+        model.computeIIS()
+        model.write("infeasible.ilp")
+        print("Model infeasible; IIS written to 'infeasible.ilp'.")
+    else:
+        print("Optimal solution found.")
+        animate_satellite_trajectories(model, time_steps)
+
+if __name__ == "__main__":
+    solve_lp_model()

achref/src/models/infeasible.ilp

@@ -0,0 +1,24 @@
+\ Model SatelliteLP_WithTracking_copy
+\ LP format - for model browsing. Use MPS format to capture full model detail.
+Minimize
+ 
+Subject To
+ init_p_Sat1_1: p_Sat1_0[1] = 0
+ init_v_Sat1_1: v_Sat1_0[1] = 0
+ dyn_p_Sat1_0_1: - 0.0125 u_Sat1_0[1] - p_Sat1_0[1] + p_Sat1_1[1]
+   - 5 v_Sat1_0[1] = 0
+ init_p_Sat2_1: p_Sat2_0[1] = 1.732051
+ init_v_Sat2_1: v_Sat2_0[1] = -0.0866025
+ dyn_p_Sat2_0_1: - 0.0125 u_Sat2_0[1] - p_Sat2_0[1] + p_Sat2_1[1]
+   - 5 v_Sat2_0[1] = 0
+ con_dy_Sat1_Sat2_1: - p_Sat1_1[1] + p_Sat2_1[1] + dy_Sat1_Sat2_1 = 0
+Bounds
+ -infinity <= u_Sat1_0[1] <= 10
+ u_Sat2_0[1] >= -10
+ p_Sat1_0[1] free
+ p_Sat1_1[1] free
+ v_Sat1_0[1] free
+ p_Sat2_0[1] free
+ p_Sat2_1[1] free
+ v_Sat2_0[1] free
+End

achref/src/plotting/plot_trajectories.py

@@ -0,0 +1,104 @@
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import re
+import matplotlib.animation as animation
+
+def animate_satellite_trajectories(model, time_steps, interval=200):
+    """
+    Creates a 3D animated plot of satellite trajectories and thrust vectors.
+
+    Args:
+        model (gp.Model): Solved Gurobi model containing:
+            - position variables named `p_{sat}_{t}[coord]`
+            - thrust variables named `u_{sat}_{t}[coord]`
+        time_steps (list of int): List of time step indices used in the optimization.
+        interval (int): Delay between frames in milliseconds.
+    """
+    # Extract data containers
+    positions = {}
+    thrusts = {}
+    # Patterns to match variable names
+    p_pattern = re.compile(r'p_(\w+)_(\d+)\[(\d+)\]')
+    u_pattern = re.compile(r'u_(\w+)_(\d+)\[(\d+)\]')
+
+    # Populate positions and thrusts dictionaries
+    for var in model.getVars():
+        # Position variables
+        pm = p_pattern.match(var.VarName)
+        if pm:
+            sat, t_str, coord_str = pm.groups()
+            t = int(t_str)
+            coord = int(coord_str)
+            positions.setdefault(sat, {}).setdefault(t, [0.0, 0.0, 0.0])[coord] = var.Xn
+            continue
+        # Thrust variables
+        um = u_pattern.match(var.VarName)
+        if um:
+            sat, t_str, coord_str = um.groups()
+            t = int(t_str)
+            coord = int(coord_str)
+            thrusts.setdefault(sat, {}).setdefault(t, [0.0, 0.0, 0.0])[coord] = var.Xn
+
+    sats = sorted(positions.keys())
+
+    # Prepare 3D figure
+    fig = plt.figure(figsize=(10, 8))
+    ax = fig.add_subplot(111, projection='3d')
+    ax.set_xlabel('X (m)')
+    ax.set_ylabel('Y (m)')
+    ax.set_zlabel('Z (m)')
+    ax.set_title('Satellite Trajectories and Thrust Animation')
+
+    # Plot objects for trajectories, end markers, and quivers
+    traj_lines = {sat: ax.plot([], [], [], label=f'{sat} traj')[0] for sat in sats}
+    end_markers = {sat: ax.plot([], [], [], marker='o', linestyle='')[0] for sat in sats}
+    quiver_objs = {sat: None for sat in sats}
+
+    # Set axis limits based on all positions
+    all_x = [positions[s][t][0] for s in sats for t in positions[s]]
+    all_y = [positions[s][t][1] for s in sats for t in positions[s]]
+    all_z = [positions[s][t][2] for s in sats for t in positions[s]]
+    ax.set_xlim(min(all_x), max(all_x))
+    ax.set_ylim(min(all_y), max(all_y))
+    ax.set_zlim(min(all_z), max(all_z))
+    ax.legend()
+
+    def update(frame):
+        # Remove previous quivers
+        for sat in sats:
+            if quiver_objs[sat] is not None:
+                quiver_objs[sat].remove()
+
+        # Update each satellite's trajectory, marker, and thrust arrow
+        for sat in sats:
+            # Trajectory up to current frame
+            xs = [positions[sat][t][0] for t in time_steps if t <= frame]
+            ys = [positions[sat][t][1] for t in time_steps if t <= frame]
+            zs = [positions[sat][t][2] for t in time_steps if t <= frame]
+            traj_lines[sat].set_data(xs, ys)
+            traj_lines[sat].set_3d_properties(zs)
+
+            # End marker at last position
+            if xs:
+                end_markers[sat].set_data([xs[-1]], [ys[-1]])
+                end_markers[sat].set_3d_properties([zs[-1]])
+
+            # Thrust arrow at this frame
+            ux, uy, uz = thrusts.get(sat, {}).get(frame, [0.0, 0.0, 0.0])
+            # Draw new quiver
+            quiver_objs[sat] = ax.quiver(
+                xs[-1], ys[-1], zs[-1], ux, uy, uz,
+                length=1e3, normalize=True
+            )
+
+        # Return artists to update
+        artists = list(traj_lines.values()) + list(end_markers.values())
+        artists += [q for q in quiver_objs.values() if q is not None]
+        return artists
+
+    # Create animation
+    ani = animation.FuncAnimation(
+        fig, update, frames=time_steps, interval=interval, blit=False
+    )
+    ani.save("satellite_trajectories.gif", writer='imagemagick', fps=5)
+    plt.show()

app.py

@@ -0,0 +1,63 @@
+import gradio as gr
+import pandas as pd
+import os
+from ui.gradio_sections import (
+    project_info_tab,
+    production_planning_tab,
+    vehicle_routing_tab,
+)
+from models.gurobi_models import solve_pl, solve_plne
+
+# Mock Data
+pl_df = pd.DataFrame(
+    {
+        "Product": ["A", "B", "C"],
+        "Profit/Unit": [15, 20, 15],
+        "Resource Usage": [3, 5, 2],
+    }
+)
+
+plne_df = pd.DataFrame([
+    {"Node": 0, "X": 50, "Y": 50, "Demand": 0},
+    {"Node": 1, "X": 20, "Y": 20, "Demand": 10},
+    {"Node": 2, "X": 80, "Y": 20, "Demand": 15},
+    {"Node": 3, "X": 20, "Y": 80, "Demand": 10},
+    {"Node": 4, "X": 80, "Y": 80, "Demand": 10},
+    {"Node": 5, "X": 50, "Y": 10, "Demand": 20},
+])
+
+
+# Descriptions
+pl_description = """
+### 🏭 Production Planning (PL)
+Select the quantity of each product to produce to **maximize profit**, under limited resource constraints.
+"""
+
+plne_description = """
+### 🚚 Capacitated Vehicle Routing Problem
+Provide node coordinates and demands, plus vehicle capacity and number of vehicles.         
+"""
+
+# Read and encode the PDF - go up one directory to find assets at project root
+favicon_path = os.path.join(os.path.dirname(__file__), "assets", "favicon.ico")
+
+# Assemble UI
+with gr.Blocks(title="Operations Research App") as ro_app:
+    gr.Markdown(
+        """
+    <div style="display: flex; align-items: center; gap: 20px;">
+        <img src="https://insat.rnu.tn/assets/images/logo_c.png" width="100">
+        <div>
+            <h1 style="margin-bottom: 5px;">Operations Research Project</h1>
+            <p style="margin-top: 0; font-size: 14px; color: gray;">Choose the convenient tab to solve a problem</p>
+        </div>
+    </div>
+    """
+    )
+    with gr.Tabs():
+        project_info_tab()
+        production_planning_tab(pl_df, solve_pl, pl_description)
+        vehicle_routing_tab(plne_df, solve_plne, plne_description)
+
+if __name__ == "__main__":
+    ro_app.launch(favicon_path=favicon_path)

models/gurobi_models.py

@@ -0,0 +1,224 @@
+from gurobipy import Model, GRB
+import pandas as pd
+import math
+from gurobipy import quicksum
+import matplotlib.pyplot as plt
+import achref.src.logger as logger
+
+logger = logger.get_logger(__name__)
+
+def solve_pl(data, total_resource=100):
+    model = Model("ProductionPlanning")
+    logger.info("Starting Gurobi model for production planning")
+    logger.info("Data: %s", data)
+    # Turn off solver output
+    model.setParam("OutputFlag", 0) 
+
+    # Extract product info
+    products = data["Product"].tolist()
+    profits = data["Profit/Unit"].tolist()
+    usage = data["Resource Usage"].tolist()
+
+    # Create decision variables
+    x = {
+        prod: model.addVar(name=f"x_{prod}", lb=0, vtype=GRB.CONTINUOUS)
+        for prod in products
+    }
+
+    # Objective: Maximise total profit
+    model.setObjective(
+        sum(profits[i] * x[products[i]] for i in range(len(products))),
+        GRB.MAXIMIZE,
+    )
+
+    # Constraint: total resource usage <= available
+    model.addConstr(
+        sum(usage[i] * x[products[i]] for i in range(len(products))) <= total_resource,
+        name="ResourceConstraint",
+    )
+
+    # Solve
+    model.optimize()
+
+    # Extract results
+    result_df = pd.DataFrame({
+        "Product": products,
+        "Quantity Produced": [x[prod].X for prod in products],
+        "Profit": [x[prod].X * profits[i] for i, prod in enumerate(products)]
+    })
+    
+    result_df["Profit per Resource"] = result_df["Profit"] / data["Resource Usage"]
+
+    # Prepare a single figure with 5 subplots
+    fig, axs = plt.subplots(3, 2, figsize=(14, 12))
+    fig.suptitle("Production Planning Visualisations", fontsize=16, y=1.02)
+
+    # Plot 1: Quantity Produced
+    axs[0, 0].bar(result_df["Product"], result_df["Quantity Produced"])
+    axs[0, 0].set_title("Quantity Produced per Product")
+
+    # Plot 2: Stacked Bar (Quantity + Profit)
+    axs[0, 1].bar(result_df["Product"], result_df["Quantity Produced"], label="Quantity")
+    axs[0, 1].bar(result_df["Product"], result_df["Profit"], 
+                  bottom=result_df["Quantity Produced"], label="Profit", alpha=0.6)
+    axs[0, 1].set_title("Stacked Bar: Quantity + Profit")
+    axs[0, 1].legend()
+
+    # Plot 3: Pie Chart of Profit
+    axs[1, 0].pie(result_df["Profit"], labels=result_df["Product"], autopct='%1.1f%%')
+    axs[1, 0].set_title("Profit Share per Product")
+
+    # Plot 4: Cumulative Profit
+    df_sorted = result_df.sort_values(by="Profit", ascending=False).reset_index(drop=True)
+    df_sorted["Cumulative Profit"] = df_sorted["Profit"].cumsum()
+    axs[1, 1].plot(df_sorted["Product"], df_sorted["Cumulative Profit"], marker="o")
+    axs[1, 1].set_title("Cumulative Profit by Product")
+    axs[1, 1].set_ylabel("Cumulative Profit")
+
+    # Plot 5: Profit per Resource
+    axs[2, 0].bar(result_df["Product"], result_df["Profit per Resource"])
+    axs[2, 0].set_title("Profit per Unit of Resource Used")
+    axs[2, 0].set_ylabel("Efficiency")
+
+    # Remove unused subplot (bottom right)
+    axs[2, 1].axis('off')
+
+    fig.tight_layout()
+
+    return result_df, fig
+
+
+def solve_plne(data: pd.DataFrame, vehicle_capacity: float, num_vehicles: int):
+    """
+    data: DataFrame with columns ["Node","X","Y","Demand"]
+    vehicle_capacity: capacity Q of each vehicle
+    num_vehicles: number of vehicles K
+    Returns: (routes_df, fig)
+      - routes_df: DataFrame with columns ["Route","Sequence","Load","Distance"]
+      - fig: matplotlib.figure.Figure with the route‐map and summary bars
+    """
+    # 1. Parse inputs
+    coords = {int(r.Node): (r.X, r.Y) for _, r in data.iterrows()}
+    demand = {int(r.Node): r.Demand for _, r in data.iterrows()}
+    nodes = list(coords.keys())
+    depot = 0
+    customers = [i for i in nodes if i != depot]
+    Q = vehicle_capacity
+    K = num_vehicles
+
+    # 2. Precompute distances
+    cost = {
+        (i, j): math.hypot(coords[i][0] - coords[j][0],
+                           coords[i][1] - coords[j][1])
+        for i in nodes for j in nodes if i != j
+    }
+
+    # 3. Build model
+    m = Model("CVRP")
+    m.setParam("OutputFlag", 0)
+
+    # Decision vars
+    x = m.addVars(cost.keys(), vtype=GRB.BINARY, name="x")
+    u = m.addVars(nodes, lb=0, ub=Q, vtype=GRB.CONTINUOUS, name="u")
+
+    # Objective
+    m.setObjective(quicksum(cost[i, j] * x[i, j] for i, j in cost), GRB.MINIMIZE)
+
+    # Degree constraints
+    m.addConstrs(
+        (quicksum(x[i, j] for j in nodes if j != i) == 1 for i in customers),
+        name="leave"
+    )
+    m.addConstrs(
+        (quicksum(x[i, j] for i in nodes if i != j) == 1 for j in customers),
+        name="enter"
+    )
+    # Depot flow
+    m.addConstr(quicksum(x[depot, j] for j in customers) == K, "dep_out")
+    m.addConstr(quicksum(x[i, depot] for i in customers) == K, "dep_in")
+
+    # MTZ subtour‐elimination & capacity
+    m.addConstrs(
+        (u[i] - u[j] + Q * x[i, j] <= Q - demand[j]
+         for i in customers for j in customers if i != j),
+        name="mtz"
+    )
+    m.addConstr(u[depot] == 0, "depot_load")
+
+    # Solve
+    m.optimize()
+
+    # 4. Extract x‐values
+    sol = m.getAttr('x', x)
+
+    # 4a. Find exactly which customers each vehicle leaves the depot to serve
+    starts = [ j for (i,j),val in sol.items() 
+               if i == depot and val > 0.5 ]
+    # sanity check
+    if len(starts) != K:
+        raise ValueError(f"Expected {K} routes out of depot, got {len(starts)}")
+
+    # 4b. Build a succ map for ALL non‐depot nodes (each has exactly 1 outgoing)
+    succ = { i: j for (i,j),val in sol.items() 
+             if i != depot and val > 0.5 }
+
+    # 4c. Now reconstruct each of the K routes
+    routes = []
+    for start in starts:
+        route = [depot, start]
+        cur = start
+        while cur != depot:
+            nxt = succ[cur]
+            route.append(nxt)
+            cur = nxt
+        routes.append(route)
+
+    # 5. Build result DataFrame
+    rows = []
+    for ridx, route in enumerate(routes, start=1):
+        load = sum(demand[n] for n in route if n != depot)
+        dist = sum(
+            math.hypot(coords[route[i]][0] - coords[route[i+1]][0],
+                       coords[route[i]][1] - coords[route[i+1]][1])
+            for i in range(len(route)-1)
+        )
+        rows.append({
+            "Route": ridx,
+            "Sequence": "→".join(str(n) for n in route),
+            "Load": load,
+            "Distance": dist
+        })
+    routes_df = pd.DataFrame(rows)
+
+    # 6. Create plots
+    fig, axs = plt.subplots(1, 2, figsize=(14,6))
+
+    # Plot A: Map of routes
+    ax = axs[0]
+    ax.scatter(*zip(*[coords[i] for i in customers]),
+               c='blue', label='Customers')
+    ax.scatter(*coords[depot], c='red', s=100, label='Depot')
+    colors = plt.cm.get_cmap('tab10', K)
+
+    for ridx, route in enumerate(routes):
+        pts = [coords[n] for n in route]
+        xs, ys = zip(*pts)
+        ax.plot(xs, ys, '-o', color=colors(ridx), label=f'Route {ridx+1}')
+    ax.set_title("Vehicle Routes")
+    ax.legend(loc='upper right')
+
+    # Plot B: Route loads & distances
+    ax2 = axs[1]
+    bar_width = 0.35
+    idx = range(len(routes_df))
+    ax2.bar(idx, routes_df["Load"], bar_width, label="Load")
+    ax2.bar([i+bar_width for i in idx], routes_df["Distance"],
+            bar_width, label="Distance")
+    ax2.set_xticks([i+bar_width/2 for i in idx])
+    ax2.set_xticklabels([f"R{r}" for r in routes_df["Route"]])
+    ax2.set_ylabel("Units / Distance")
+    ax2.set_title("Load vs Distance per Route")
+    ax2.legend()
+
+    fig.tight_layout()
+    return routes_df, fig

requirements.txt

@@ -0,0 +1,4 @@
+python-dotenv==1.1.0
+pydantic==2.8.2
+pydantic_settings==2.4.0
+gurobipy==12.0.1

ui/gradio_sections.py

@@ -0,0 +1,230 @@
+import gradio as gr
+import os
+import base64
+import sys
+import pandas as pd                                                        
+import achref.src.logger as logger
+
+logger = logger.get_logger(__name__)
+
+def project_info_tab():
+    with gr.Tab("📘 Project Info"):
+        gr.Markdown(
+            """
+        # 🎓 GL3 - 2025 - Operational Research Project
+        This application demonstrates how **Linear Programming (PL)** and **Mixed-Integer Linear Programming (PLNE)** can be applied to solve real-world optimisation problems using **Gurobi**.
+        
+        ---
+        # 👥 Project Members
+        - **Kacem Mathlouthi** — GL3/2  
+        - **Mohamed Amine Houas** — GL3/1  
+        - **Oussema Kraiem** — GL3/2  
+        - **Yassine Taieb** — GL3/2  
+        - **Youssef Sghairi** — GL3/2  
+        - **Youssef Aaridhi** — GL3/2  
+        - **Achref Ben Ammar** — GL3/1  
+        ---
+        # 🧾 Compte Rendu
+        """
+        )
+        pdf_path = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "assets", "compte_rendu.pdf"
+        )
+        with open(pdf_path, "rb") as pdf_file:
+            encoded_pdf = base64.b64encode(pdf_file.read()).decode("utf-8")
+
+        # Display using data URI
+        gr.HTML(
+            f"""
+        <embed src="data:application/pdf;base64,{encoded_pdf}" type="application/pdf" width="100%" height="1200px">
+        """
+        )
+
+
+def production_planning_tab(mock_pl_df, solve_pl_gurobi, pl_description):
+    with gr.Tab("🏭 Production Planning (PL)"):
+        gr.Markdown(pl_description)
+
+        # Add mathematical model description
+        gr.Markdown(
+            r"""
+            ### 🧮 Mathematical Formulation
+
+            Let:  
+            | Symbol      | Description                             |
+            |-------------|-----------------------------------------|
+            | $$x_i$$       | Number of units to produce for product i |
+            | $$p_i$$       | Profit per unit for product i         |
+            | $$r_i$$       | Resource usage per unit for product i |
+            | $$R$$         | Total resource available              |
+
+            **Objective:**  
+            $$
+            \text{Maximise} \quad \sum_i p_i \cdot x_i
+            $$
+
+            **Constraint:**  
+            $$
+            \sum_i r_i \cdot x_i \leq R \quad \text{and} \quad x_i \geq 0
+            $$
+            """
+        )
+
+        with gr.Row():
+            input_pl = gr.Dataframe(
+                headers=["Product", "Profit/Unit", "Resource Usage"],
+                value=mock_pl_df,
+                label="Input Product Data",
+            )
+        total_resource_input = gr.Number(
+            value=100, label="Total Resource Available (R)"
+        )
+        solve_btn_pl = gr.Button("Solve Production Problem")
+
+        result_table_pl = gr.Dataframe(label="Optimised Result")
+        
+        # Create plot output placeholders
+        result_plot_combined = gr.Plot(label="Data Visualisation")
+
+        def _solve_with_floats(df, R):
+                df["Profit/Unit"]     = df["Profit/Unit"].astype(float)
+                df["Resource Usage"]  = df["Resource Usage"].astype(float)
+                return solve_pl_gurobi(df, total_resource=R)
+        
+        solve_btn_pl.click(
+            fn=_solve_with_floats,
+            inputs=[input_pl, total_resource_input],
+            outputs=[
+                result_table_pl,
+                result_plot_combined,
+            ]
+        )
+
+
+# in gradio_sections.py
+
+def vehicle_routing_tab(mock_plne_df, solve_plne, plne_description):
+    
+    with gr.Tab("🚚 Vehicle Routing (PLNE)"):
+        gr.Markdown(plne_description)
+        # Log the Python path of the project
+        gr.HTML(
+            '<img src="https://pyvrp.readthedocs.io/en/latest/_images/introduction-to-vrp.svg" '
+            'alt="VRP Problem Illustration" width="600px" />'
+        )
+        gr.Markdown(
+            r"""
+            ### 🧮 Mathematical Formulation (Capacitated VRP)
+
+
+            | Symbol                         | Description                                                   |
+            |--------------------------------|---------------------------------------------------------------|
+            | $$i,j \in N=\{0,\dots,n\}$$    | Nodes (0 = depot, 1..n = customers)                           |
+            | $$K$$                          | Number of vehicles                                            |
+            | $$c_{ij}$$                     | Travel cost (distance) from node `i` to node `j`              |  
+            | $$d_i$$                        | Demand at customer `i`                                        |
+            | $$Q$$                          | Vehicle capacity                                              |
+            | $$x_{ij}\in\{0,1\}$$           | 1 if a vehicle travels directly from `i` to `j`               |
+            | $$u_i\ge0$$                    | Load on the vehicle immediately after visiting node `i`       |
+
+            **Objective**  
+            $$
+            \min \sum_{i\in N}\sum_{\substack{j\in N \\ j\neq i}} c_{ij}\,x_{ij}
+            $$  
+            Minimize the **total travel cost** of all vehicles.
+
+            ---
+
+            **Subject to**
+
+            1. **Degree constraints**  
+            $$
+            \sum_{j\neq i} x_{ij} = 1
+            \quad \forall\, i\neq0
+            $$
+            $$
+            \sum_{i\neq j} x_{ij} = 1
+            \quad \forall\, j\neq0
+            $$
+            > *Explanation:* Every customer `i` must have exactly one vehicle leaving it and one arriving—ensuring each customer is visited exactly once.
+
+            2. **Depot flow**  
+            $$
+            \sum_{j>0} x_{0j} = K
+            $$
+            $$
+            \sum_{i>0} x_{i0} = K
+            $$
+            > *Explanation:* Exactly `K` vehicles depart from the depot and `K` return, so all vehicles are used and end back at the depot.
+
+            3. **MTZ subtour-elimination & capacity**  
+            $$
+            u_i - u_j + Q\,x_{ij} \le Q - d_j
+            \quad \forall\,i\neq j,\; i,j>0
+            $$
+            $$
+            u_0 = 0
+            $$
+            $$
+            0 \le u_i \le Q
+            $$
+            > *Explanation:*  
+            > - If `x_{ij}=1`, then $$u_j \ge u_i + d_j$$ enforcing vehicle capacity.  
+            > - These constraints also prevent any customer‐only loops (subtours), because load can’t reset without returning to the depot.  
+            > - We fix `u_0=0` at the depot and bound `u_i` by capacity `Q`.
+
+
+            ---
+
+           
+
+"""
+        )
+    
+        vrp_input = gr.Dataframe(
+                    headers=["Node", "X", "Y", "Demand"],
+                    value=mock_plne_df,
+                    label="Input Vehicle Routing Data",
+                )
+        with gr.Row():
+            cap_input = gr.Number(value=40, label="Vehicle capacity (Q)")
+            k_input   = gr.Number(value=2, label="Number of vehicles (K)")
+        solve_btn = gr.Button("Solve VRP")
+        status_output = gr.Textbox(label="Status", interactive=False)
+        result_table = gr.Dataframe(label="Routes Summary")
+        result_plot  = gr.Plot(label="Route Map & Summary")
+
+        def _solve_vrp_with_floats(df, Q, K):
+            df["X"]      = df["X"].astype(float)
+            df["Y"]      = df["Y"].astype(float)
+            df["Demand"] = df["Demand"].astype(float)
+            
+            # skip depot (assumed Node==0) when checking
+            custs = df[df["Node"] != 0]
+
+            try:
+                # 1) any single demand > Q?
+                too_big = custs[custs["Demand"] > Q]
+                if not too_big.empty:
+                    bad = int(too_big["Node"].iloc[0])
+                    raise ValueError(f"Client {bad} demand ({too_big['Demand'].iloc[0]}) exceeds capacity Q={Q}")
+
+                # 2) total demand > Q*K?
+                total = custs["Demand"].sum()
+                if total > Q * K:
+                    raise ValueError(f"Total demand ({total}) exceeds fleet capacity Q*K={Q*K}")
+
+                # all good → call solver
+                routes_df, fig = solve_plne(df, vehicle_capacity=Q, num_vehicles=K)
+                return routes_df, fig, "All Good"
+            except ValueError as e:
+                # on error show empty table/plot + message
+                return pd.DataFrame(), None, str(e)
+        
+        
+        solve_btn.click(
+            fn=_solve_vrp_with_floats,
+            inputs=[vrp_input, cap_input, k_input],
+            outputs=[result_table, result_plot, status_output],
+        )
+