New PL Model

app.py

@@ -1,43 +1,110 @@
+import os
+
 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
+
+from models.gurobi_models import solve_plne, solve_refinery_optimization
+from ui.gradio_sections import oil_refinery_tab, project_info_tab, vehicle_routing_tab
 
 # 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},
+    ]
 )
 
-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},
-])
+# Oil Refinery Optimization Mock Data
+crude_df = pd.DataFrame(
+    [
+        {"Crude": "Light Crude", "Cost": 60, "Availability": 10000},
+        {"Crude": "Medium Crude", "Cost": 50, "Availability": 15000},
+        {"Crude": "Heavy Crude", "Cost": 45, "Availability": 12000},
+    ]
+)
 
+product_df = pd.DataFrame(
+    [
+        {"Product": "Premium Gasoline", "Price": 90, "Demand": 5000},
+        {"Product": "Regular Gasoline", "Price": 80, "Demand": 7000},
+        {"Product": "Diesel", "Price": 75, "Demand": 8000},
+    ]
+)
 
-# Descriptions
-pl_description = """
-### 🏭 Production Planning (PL)
-Select the quantity of each product to produce to **maximize profit**, under limited resource constraints.
-"""
+yields_df = pd.DataFrame(
+    [
+        # Light Crude yields
+        {
+            "Crude": "Light Crude",
+            "Product": "Premium Gasoline",
+            "Yield": 0.4,
+            "Quality": 95,
+        },
+        {
+            "Crude": "Light Crude",
+            "Product": "Regular Gasoline",
+            "Yield": 0.3,
+            "Quality": 90,
+        },
+        {"Crude": "Light Crude", "Product": "Diesel", "Yield": 0.2, "Quality": 85},
+        # Medium Crude yields
+        {
+            "Crude": "Medium Crude",
+            "Product": "Premium Gasoline",
+            "Yield": 0.3,
+            "Quality": 85,
+        },
+        {
+            "Crude": "Medium Crude",
+            "Product": "Regular Gasoline",
+            "Yield": 0.4,
+            "Quality": 80,
+        },
+        {"Crude": "Medium Crude", "Product": "Diesel", "Yield": 0.3, "Quality": 80},
+        # Heavy Crude yields
+        {
+            "Crude": "Heavy Crude",
+            "Product": "Premium Gasoline",
+            "Yield": 0.1,
+            "Quality": 75,
+        },
+        {
+            "Crude": "Heavy Crude",
+            "Product": "Regular Gasoline",
+            "Yield": 0.3,
+            "Quality": 70,
+        },
+        {"Crude": "Heavy Crude", "Product": "Diesel", "Yield": 0.5, "Quality": 75},
+    ]
+)
+
+quality_reqs_df = pd.DataFrame(
+    [
+        {"Product": "Premium Gasoline", "MinQuality": 90},
+        {"Product": "Regular Gasoline", "MinQuality": 80},
+        {"Product": "Diesel", "MinQuality": 75},
+    ]
+)
 
+# Descriptions
 plne_description = """
 ### 🚚 Capacitated Vehicle Routing Problem
 Provide node coordinates and demands, plus vehicle capacity and number of vehicles.         
 """
 
+refinery_description = """
+### ⚙️ Oil Refinery Optimization Problem
+
+**Scenario**
+An oil refinery wants to determine the optimal production plan for different fuel products (like diesel, premium gasoline, and regular gasoline) 
+using various crude oils. Each crude oil has different yields, costs, and qualities, and each product has its own demand, 
+quality requirements, and selling price.
+"""
+
 # 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")
 
@@ -56,7 +123,14 @@ with gr.Blocks(title="Operations Research App") as ro_app:
     )
     with gr.Tabs():
         project_info_tab()
-        production_planning_tab(pl_df, solve_pl, pl_description)
+        oil_refinery_tab(
+            crude_df,
+            product_df,
+            yields_df,
+            quality_reqs_df,
+            solve_refinery_optimization,
+            refinery_description,
+        )
         vehicle_routing_tab(plne_df, solve_plne, plne_description)
 
 if __name__ == "__main__":

models/gurobi_models.py

@@ -1,91 +1,349 @@
-from gurobipy import Model, GRB
-import pandas as pd
 import math
-from gurobipy import quicksum
+
 import matplotlib.pyplot as plt
+import pandas as pd
+from gurobipy import GRB, Model, quicksum
+
 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
+
+def solve_refinery_optimization(
+    crude_data, product_data, crude_product_yields, product_quality_reqs
+):
+    """
+    Solves the Oil Refinery Optimization Problem.
+
+    Args:
+        crude_data (pd.DataFrame): DataFrame with columns ["Crude", "Cost", "Availability"]
+        product_data (pd.DataFrame): DataFrame with columns ["Product", "Price", "Demand"]
+        crude_product_yields (pd.DataFrame): DataFrame with columns ["Crude", "Product", "Yield", "Quality"]
+        product_quality_reqs (pd.DataFrame): DataFrame with columns ["Product", "MinQuality"]
+
+    Returns:
+        tuple: (result_df, fig) where result_df contains the optimal solution and fig is a matplotlib figure
+    """
+    if not all(
+        isinstance(df, pd.DataFrame)
+        for df in [crude_data, product_data, crude_product_yields, product_quality_reqs]
+    ):
+        raise TypeError("All inputs must be pandas DataFrames")
+
+    # Validate required columns
+    if not set(["Crude", "Cost", "Availability"]).issubset(crude_data.columns):
+        raise ValueError("crude_data must contain columns: Crude, Cost, Availability")
+    if not set(["Product", "Price", "Demand"]).issubset(product_data.columns):
+        raise ValueError("product_data must contain columns: Product, Price, Demand")
+    if not set(["Crude", "Product", "Yield", "Quality"]).issubset(
+        crude_product_yields.columns
+    ):
+        raise ValueError(
+            "crude_product_yields must contain columns: Crude, Product, Yield, Quality"
+        )
+    if not set(["Product", "MinQuality"]).issubset(product_quality_reqs.columns):
+        raise ValueError(
+            "product_quality_reqs must contain columns: Product, MinQuality"
+        )
+
+    logger.info("Starting Gurobi model for Oil Refinery Optimization")
+
+    # Create optimization model
+    model = Model("OilRefineryOptimization")
+    model.setParam("OutputFlag", 0)
+
+    # Get unique crudes and products
+    crudes = crude_data["Crude"].unique().tolist()
+    products = product_data["Product"].unique().tolist()
+
+    # Extract data
+    costs = {row["Crude"]: row["Cost"] for _, row in crude_data.iterrows()}
+    availability = {
+        row["Crude"]: row["Availability"] for _, row in crude_data.iterrows()
+    }
+    prices = {row["Product"]: row["Price"] for _, row in product_data.iterrows()}
+    demands = {row["Product"]: row["Demand"] for _, row in product_data.iterrows()}
+    min_qualities = {
+        row["Product"]: row["MinQuality"] for _, row in product_quality_reqs.iterrows()
     }
 
-    # Objective: Maximise total profit
-    model.setObjective(
-        sum(profits[i] * x[products[i]] for i in range(len(products))),
-        GRB.MAXIMIZE,
-    )
+    # Create a dictionary for yields and qualities
+    yields = {}
+    qualities = {}
+    for _, row in crude_product_yields.iterrows():
+        crude, product = row["Crude"], row["Product"]
+        yields[(crude, product)] = row["Yield"]
+        qualities[(crude, product)] = row["Quality"]
+
+    # Decision variables: amount of each crude oil used
+    x = {crude: model.addVar(name=f"x_{crude}", lb=0) for crude in crudes}
+
+    # Calculated variables: amount of each product produced from each crude
+    prod_from_crude = {}
+    for crude in crudes:
+        for product in products:
+            key = (crude, product)
+            if key in yields:
+                prod_from_crude[key] = yields[key] * x[crude]
+
+    # Calculate total production per product
+    total_production = {}
+    for product in products:
+        total_production[product] = quicksum(
+            prod_from_crude.get((crude, product), 0) for crude in crudes
+        )
 
-    # Constraint: total resource usage <= available
-    model.addConstr(
-        sum(usage[i] * x[products[i]] for i in range(len(products))) <= total_resource,
-        name="ResourceConstraint",
+    # Objective: Maximize profit (revenue - cost)
+    revenue = quicksum(
+        prices[product] * total_production[product] for product in products
     )
+    cost = quicksum(costs[crude] * x[crude] for crude in crudes)
+    model.setObjective(revenue - cost, GRB.MAXIMIZE)
+
+    # Constraints:
+
+    # 1. Crude availability constraints
+    for crude in crudes:
+        model.addConstr(x[crude] <= availability[crude], name=f"avail_{crude}")
 
-    # Solve
+    # 2. Demand satisfaction constraints
+    for product in products:
+        model.addConstr(
+            total_production[product] >= demands[product], name=f"demand_{product}"
+        )
+
+    # 3. Quality constraints
+    for product in products:
+        if product in min_qualities:
+            # Linearized quality constraint: sum(q_ij * y_ij * x_i) >= Q_j^min * sum(y_ij * x_i)
+            quality_numerator = quicksum(
+                qualities.get((crude, product), 0)
+                * yields.get((crude, product), 0)
+                * x[crude]
+                for crude in crudes
+                if (crude, product) in yields
+            )
+            model.addConstr(
+                quality_numerator >= min_qualities[product] * total_production[product],
+                name=f"quality_{product}",
+            )
+
+    # Solve the model
     model.optimize()
 
+    # Check if optimal solution was found
+    if model.status != GRB.OPTIMAL:
+        raise ValueError("Failed to find an optimal solution")
+
     # 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')
+    crude_results = pd.DataFrame(
+        {
+            "Crude": crudes,
+            "Amount Used": [x[crude].X for crude in crudes],
+            "Cost": [x[crude].X * costs[crude] for crude in crudes],
+        }
+    )
+
+    # Calculate production results
+    prod_results = []
+    for product in products:
+        prod_amount = sum(
+            prod_from_crude.get((crude, product), 0).getValue()
+            for crude in crudes
+            if (crude, product) in prod_from_crude
+        )
+        revenue = prod_amount * prices[product]
+        # Calculate average quality
+        quality_numerator = sum(
+            qualities.get((crude, product), 0)
+            * prod_from_crude.get((crude, product), 0).getValue()
+            for crude in crudes
+            if (crude, product) in prod_from_crude
+        )
+        avg_quality = quality_numerator / prod_amount if prod_amount > 0 else 0
+
+        prod_results.append(
+            {
+                "Product": product,
+                "Amount Produced": prod_amount,
+                "Revenue": revenue,
+                "Average Quality": avg_quality,
+                "Min Quality Required": min_qualities.get(product, "N/A"),
+            }
+        )
+
+    product_results_df = pd.DataFrame(prod_results)
+
+    # Create visualizations
+    fig, axs = plt.subplots(2, 2, figsize=(14, 10))
+    fig.suptitle("Oil Refinery Optimization Results", fontsize=16, y=1.02)
+
+    # Plot 1: Crude Oil Usage
+    axs[0, 0].bar(crude_results["Crude"], crude_results["Amount Used"])
+    axs[0, 0].set_title("Crude Oil Usage")
+    axs[0, 0].set_ylabel("Amount (Liters)")
+    plt.setp(axs[0, 0].get_xticklabels(), rotation=45, ha="right")
+
+    # Plot 2: Product Production
+    axs[0, 1].bar(product_results_df["Product"], product_results_df["Amount Produced"])
+    axs[0, 1].set_title("Product Production")
+    axs[0, 1].set_ylabel("Amount (Liters)")
+    plt.setp(axs[0, 1].get_xticklabels(), rotation=45, ha="right")
+
+    # Plot 3: Profit/Cost Breakdown
+    revenue_total = product_results_df["Revenue"].sum()
+    cost_total = crude_results["Cost"].sum()
+    profit = revenue_total - cost_total
+    axs[1, 0].bar(
+        ["Revenue", "Cost", "Profit"],
+        [revenue_total, cost_total, profit],
+        color=["green", "red", "blue"],
+    )
+    axs[1, 0].set_title("Financial Summary")
+    axs[1, 0].set_ylabel("Amount ($)")
+
+    # Plot 4: Quality vs Requirements
+    products = product_results_df["Product"]
+    achieved_quality = product_results_df["Average Quality"]
+    required_quality = pd.to_numeric(
+        product_results_df["Min Quality Required"], errors="coerce"
+    )
+
+    x = range(len(products))
+    width = 0.35
+    axs[1, 1].bar(
+        [i - width / 2 for i in x], achieved_quality, width, label="Achieved Quality"
+    )
+    axs[1, 1].bar(
+        [i + width / 2 for i in x], required_quality, width, label="Required Quality"
+    )
+    axs[1, 1].set_title("Product Quality Analysis")
+    axs[1, 1].set_xticks(x)
+    axs[1, 1].set_xticklabels(products)
+    axs[1, 1].set_ylabel("Quality")
+    axs[1, 1].legend()
+    plt.setp(axs[1, 1].get_xticklabels(), rotation=45, ha="right")
 
     fig.tight_layout()
 
-    return result_df, fig
+    # Combine results for return
+    combined_results = {
+        "Crude Usage": crude_results,
+        "Product Production": product_results_df,
+        "Total Profit": profit,
+    }
+
+    # Convert to a results dataframe with all key information
+    result_summary = pd.DataFrame(
+        {
+            "Category": ["Total Revenue", "Total Cost", "Total Profit"],
+            "Value": [revenue_total, cost_total, profit],
+        }
+    )
+
+    return product_results_df, fig
+
+
+def _validate_plne_input(data, vehicle_capacity, num_vehicles):
+    required_cols = {"Node", "X", "Y", "Demand"}
+    if not isinstance(data, pd.DataFrame):
+        raise TypeError("Input 'data' must be a pandas DataFrame.")
+    if not required_cols.issubset(data.columns):
+        missing = required_cols - set(data.columns)
+        raise ValueError(f"Missing required columns in 'data': {missing}")
+    if not isinstance(vehicle_capacity, (int, float)) or vehicle_capacity <= 0:
+        raise ValueError("'vehicle_capacity' must be a positive number.")
+    if not isinstance(num_vehicles, int) or num_vehicles <= 0:
+        raise ValueError("'num_vehicles' must be a positive integer.")
+
+
+def _prepare_plne_data(data):
+    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
+    if depot not in nodes:
+        raise ValueError("Depot node (0) is missing from input.")
+    customers = [i for i in nodes if i != depot]
+    return coords, demand, nodes, depot, customers
+
+
+def _compute_distance_matrix(coords, nodes):
+    return {
+        (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
+    }
+
+
+def _reconstruct_routes(sol, depot, K):
+    starts = [j for (i, j), val in sol.items() if i == depot and val > 0.5]
+    if len(starts) != K:
+        raise ValueError(f"Expected {K} routes out of depot, got {len(starts)}")
+    succ = {i: j for (i, j), val in sol.items() if i != depot and val > 0.5}
+    routes = []
+    for start in starts:
+        route = [depot, start]
+        cur = start
+        while cur != depot:
+            nxt = succ.get(cur)
+            if nxt is None:
+                raise ValueError(f"Incomplete route starting at node {start}.")
+            route.append(nxt)
+            cur = nxt
+        routes.append(route)
+    return routes
+
+
+def _build_routes_df(routes, demand, coords, depot):
+    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,
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def _plot_plne(routes, routes_df, coords, customers, depot, K):
+    fig, axs = plt.subplots(1, 2, figsize=(14, 6))
+    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")
+    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 fig
 
 
 def solve_plne(data: pd.DataFrame, vehicle_capacity: float, num_vehicles: int):
@@ -97,128 +355,202 @@ def solve_plne(data: pd.DataFrame, vehicle_capacity: float, num_vehicles: int):
       - routes_df: DataFrame with columns ["Route","Sequence","Load","Distance"]
       - fig: matplotlib.figure.Figure with the route‐map and summary bars
     """
-    # 1. Parse inputs
+    try:
+        _validate_plne_input(data, vehicle_capacity, num_vehicles)
+        coords, demand, nodes, depot, customers = _prepare_plne_data(data)
+        Q, K = vehicle_capacity, num_vehicles
+        cost = _compute_distance_matrix(coords, nodes)
+
+        m = Model("CVRP")
+        m.setParam("OutputFlag", 0)
+        x = m.addVars(cost.keys(), vtype=GRB.BINARY, name="x")
+        u = m.addVars(nodes, lb=0, ub=Q, vtype=GRB.CONTINUOUS, name="u")
+        m.setObjective(quicksum(cost[i, j] * x[i, j] for i, j in cost), GRB.MINIMIZE)
+        m.addConstrs(
+            (quicksum(x[i, j] for j in nodes if j != i) == 1 for i in customers),
+            "leave",
+        )
+        m.addConstrs(
+            (quicksum(x[i, j] for i in nodes if i != j) == 1 for j in customers),
+            "enter",
+        )
+        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")
+        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")
+        m.optimize()
+        if m.status != GRB.OPTIMAL:
+            raise ValueError("Gurobi failed to find an optimal solution.")
+        sol = m.getAttr("x", x)
+        routes = _reconstruct_routes(sol, depot, K)
+        routes_df = _build_routes_df(routes, demand, coords, depot)
+        fig = _plot_plne(routes, routes_df, coords, customers, depot, K)
+        return routes_df, fig
+    except (ValueError, TypeError) as e:
+        raise RuntimeError(f"Error in solve_plne: {e}")
+    except Exception as e:
+        raise RuntimeError(f"Unexpected error in solve_plne: {e}")
+
+
+def _validate_plne_input(data, vehicle_capacity, num_vehicles):
+    required_cols = {"Node", "X", "Y", "Demand"}
+    if not isinstance(data, pd.DataFrame):
+        raise TypeError("Input 'data' must be a pandas DataFrame.")
+    if not required_cols.issubset(data.columns):
+        missing = required_cols - set(data.columns)
+        raise ValueError(f"Missing required columns in 'data': {missing}")
+    if not isinstance(vehicle_capacity, (int, float)) or vehicle_capacity <= 0:
+        raise ValueError("'vehicle_capacity' must be a positive number.")
+    if not isinstance(num_vehicles, int) or num_vehicles <= 0:
+        raise ValueError("'num_vehicles' must be a positive integer.")
+
+
+def _prepare_plne_data(data):
     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
+    if depot not in nodes:
+        raise ValueError("Depot node (0) is missing from input.")
     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")
+    return coords, demand, nodes, depot, customers
 
-    # 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()
+def _compute_distance_matrix(coords, nodes):
+    return {
+        (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
+    }
 
-    # 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
+def _reconstruct_routes(sol, depot, K):
+    starts = [j for (i, j), val in sol.items() if i == depot and val > 0.5]
     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
+    succ = {i: j for (i, j), val in sol.items() if i != depot and val > 0.5}
     routes = []
     for start in starts:
         route = [depot, start]
         cur = start
         while cur != depot:
-            nxt = succ[cur]
+            nxt = succ.get(cur)
+            if nxt is None:
+                raise ValueError(f"Incomplete route starting at node {start}.")
             route.append(nxt)
             cur = nxt
         routes.append(route)
+    return routes
+
 
-    # 5. Build result DataFrame
+def _build_routes_df(routes, demand, coords, depot):
     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)
+            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,
+            }
+        )
+    return pd.DataFrame(rows)
+
 
+def _plot_plne(routes, routes_df, coords, customers, depot, K):
+    fig, axs = plt.subplots(1, 2, figsize=(14, 6))
+    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.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
+    ax.legend(loc="upper right")
     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.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
+    return 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
+    """
+    try:
+        _validate_plne_input(data, vehicle_capacity, num_vehicles)
+        coords, demand, nodes, depot, customers = _prepare_plne_data(data)
+        Q, K = vehicle_capacity, num_vehicles
+        cost = _compute_distance_matrix(coords, nodes)
+
+        m = Model("CVRP")
+        m.setParam("OutputFlag", 0)
+        x = m.addVars(cost.keys(), vtype=GRB.BINARY, name="x")
+        u = m.addVars(nodes, lb=0, ub=Q, vtype=GRB.CONTINUOUS, name="u")
+        m.setObjective(quicksum(cost[i, j] * x[i, j] for i, j in cost), GRB.MINIMIZE)
+        m.addConstrs(
+            (quicksum(x[i, j] for j in nodes if j != i) == 1 for i in customers),
+            "leave",
+        )
+        m.addConstrs(
+            (quicksum(x[i, j] for i in nodes if i != j) == 1 for j in customers),
+            "enter",
+        )
+        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")
+        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")
+        m.optimize()
+        if m.status != GRB.OPTIMAL:
+            raise ValueError("Gurobi failed to find an optimal solution.")
+        sol = m.getAttr("x", x)
+        routes = _reconstruct_routes(sol, depot, K)
+        routes_df = _build_routes_df(routes, demand, coords, depot)
+        fig = _plot_plne(routes, routes_df, coords, customers, depot, K)
+        return routes_df, fig
+    except (ValueError, TypeError) as e:
+        raise RuntimeError(f"Error in solve_plne: {e}")
+    except Exception as e:
+        raise RuntimeError(f"Unexpected error in solve_plne: {e}")

ui/gradio_sections.py

@@ -1,21 +1,23 @@
-import gradio as gr
-import os
 import base64
-import sys
-import pandas as pd                                                        
+import os
+
+import gradio as gr
+import pandas as pd
+
 import achref.src.logger as logger
 
 logger = logger.get_logger(__name__)
 
+
 def project_info_tab():
-    with gr.Tab("📘 Project Info"):
+    with gr.Tab("\U0001f4d8 Project Info"):
         gr.Markdown(
             """
-        # 🎓 GL3 - 2025 - Operational Research Project
+        # \U0001f393 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
+        # \U0001f465 Project Members
         - **Kacem Mathlouthi** — GL3/2  
         - **Mohamed Amine Houas** — GL3/1  
         - **Oussema Kraiem** — GL3/2  
@@ -24,7 +26,7 @@ def project_info_tab():
         - **Youssef Aaridhi** — GL3/2  
         - **Achref Ben Ammar** — GL3/1  
         ---
-        # 🧾 Compte Rendu
+        # \U0001f9fe Compte Rendu
         """
         )
         pdf_path = os.path.join(
@@ -41,80 +43,130 @@ def project_info_tab():
         )
 
 
-def production_planning_tab(mock_pl_df, solve_pl_gurobi, pl_description):
-    with gr.Tab("🏭 Production Planning (PL)"):
-        gr.Markdown(pl_description)
+def oil_refinery_tab(
+    mock_crude_data,
+    mock_product_data,
+    mock_yields_data,
+    mock_quality_reqs,
+    solve_refinery_optimization,
+    refinery_description,
+):
+    with gr.Tab("\U0001f3ed Oil Refinery Optimization (PL)"):
+        gr.Markdown(refinery_description)
 
         # Add mathematical model description
         gr.Markdown(
             r"""
             ### 🧮 Mathematical Formulation
 
-            Let:  
+            **Sets and Indices**
             | 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              |
+            | $$i=1,...,m$$       | Types of crude oil (inputs) |
+            | $$j=1,...,n$$       | Types of fuel products (outputs) |
+
+            **Parameters**
+            | Symbol      | Description                             |
+            |-------------|-----------------------------------------|
+            | $$c_i$$       | Cost per unit of crude $i$ |
+            | $$p_j$$       | Selling price per unit of product $j$ |
+            | $$y_{ij}$$    | Yield of product $j$ from crude $i$ (liters of product per liter of crude) |
+            | $$q_{ij}$$    | Quality contribution of crude $i$ to product $j$ |
+            | $$Q_j^{min}$$ | Minimum average quality required for product $j$ |
+            | $$D_j$$       | Minimum demand (liters) for product $j$ |
+            | $$A_i$$       | Availability limit (liters) of crude $i$ |
+
+            **Decision Variables**
+            | Symbol      | Description                             |
+            |-------------|-----------------------------------------|
+            | $$x_i$$       | Amount of crude oil $i$ used (liters) |
 
             **Objective:**  
             $$
-            \text{Maximise} \quad \sum_i p_i \cdot x_i
+            \text{Maximize} \quad \left(\sum_{j=1}^n p_j \cdot \sum_{i=1}^m y_{ij} \cdot x_i - \sum_{i=1}^m c_i \cdot x_i\right)
             $$
 
-            **Constraint:**  
-            $$
-            \sum_i r_i \cdot x_i \leq R \quad \text{and} \quad x_i \geq 0
-            $$
+            **Constraints:**  
+            1. Crude Availability:
+            $$x_i \leq A_i \quad \forall i$$
+
+            2. Demand Satisfaction:
+            $$\sum_{i=1}^m y_{ij} \cdot x_i \geq D_j \quad \forall j$$
+
+            3. Quality Requirements:
+            $$\sum_{i=1}^m q_{ij} \cdot y_{ij} \cdot x_i \geq Q_j^{min} \cdot \sum_{i=1}^m y_{ij} \cdot x_i \quad \forall j$$
+
+            4. Non-negativity:
+            $$x_i \geq 0 \quad \forall i$$
             """
         )
 
-        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")
+        with gr.Tabs():
+            with gr.TabItem("Crude Oils"):
+                crude_input = gr.Dataframe(
+                    headers=["Crude", "Cost", "Availability"],
+                    value=mock_crude_data,
+                    label="Crude Oil Data",
+                )
 
-        result_table_pl = gr.Dataframe(label="Optimised Result")
-        
-        # Create plot output placeholders
-        result_plot_combined = gr.Plot(label="Data Visualisation")
+            with gr.TabItem("Products"):
+                product_input = gr.Dataframe(
+                    headers=["Product", "Price", "Demand"],
+                    value=mock_product_data,
+                    label="Product Data",
+                )
 
-        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,
-            ]
-        )
+            with gr.TabItem("Yields & Quality"):
+                yields_input = gr.Dataframe(
+                    headers=["Crude", "Product", "Yield", "Quality"],
+                    value=mock_yields_data,
+                    label="Yield & Quality Data",
+                )
 
+            with gr.TabItem("Quality Requirements"):
+                quality_reqs_input = gr.Dataframe(
+                    headers=["Product", "MinQuality"],
+                    value=mock_quality_reqs,
+                    label="Quality Requirements",
+                )
+
+        solve_btn = gr.Button("Solve Refinery Optimization Problem")
+        status_output = gr.Textbox(label="Status", interactive=False)
+        results_table = gr.Dataframe(label="Optimization Results")
+        results_plot = gr.Plot(label="Results Visualization")
+
+        def _solve_refinery_problem(crude_df, product_df, yields_df, quality_df):
+            try:
+                # Convert all numeric columns to float
+                for df in [crude_df, product_df, yields_df, quality_df]:
+                    for col in df.columns:
+                        if col not in ["Crude", "Product"]:
+                            df[col] = pd.to_numeric(df[col], errors="coerce")
+
+                result_df, fig = solve_refinery_optimization(
+                    crude_df, product_df, yields_df, quality_df
+                )
+                return result_df, fig, "Solved Successfully"
+            except Exception as e:
+                return pd.DataFrame(), None, f"❌ Error: {str(e)}"
+
+        solve_btn.click(
+            fn=_solve_refinery_problem,
+            inputs=[crude_input, product_input, yields_input, quality_reqs_input],
+            outputs=[results_table, results_plot, status_output],
+        )
 
-# in gradio_sections.py
 
 def vehicle_routing_tab(mock_plne_df, solve_plne, plne_description):
-    
-    with gr.Tab("🚚 Vehicle Routing (PLNE)"):
+    with gr.Tab("\U0001f69a 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)
+            ### \U0001F9EE Mathematical Formulation (Capacitated VRP)
 
 
             | Symbol                         | Description                                                   |
@@ -146,7 +198,6 @@ def vehicle_routing_tab(mock_plne_df, solve_plne, plne_description):
             \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**  
             $$
@@ -155,7 +206,6 @@ def vehicle_routing_tab(mock_plne_df, solve_plne, plne_description):
             $$
             \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**  
             $$
@@ -168,63 +218,50 @@ def vehicle_routing_tab(mock_plne_df, solve_plne, plne_description):
             $$
             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",
-                )
+            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)")
+            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")
+        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?
+                df["X"] = df["X"].astype(float)
+                df["Y"] = df["Y"].astype(float)
+                df["Demand"] = df["Demand"].astype(float)
+
+                custs = df[df["Node"] != 0]
+
                 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}")
+                    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}")
+                    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)
-        
-        
+                return routes_df, fig, "Solved Successfully"
+            except Exception as e:
+                return pd.DataFrame(), None, f"❌ Error: {str(e)}"
+
         solve_btn.click(
             fn=_solve_vrp_with_floats,
             inputs=[vrp_input, cap_input, k_input],
             outputs=[result_table, result_plot, status_output],
-        )
-
+        )