Update

achref/README.md

@@ -1,60 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-\ 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

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

achref/src/config/config.py

@@ -1,39 +0,0 @@
-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

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

achref/src/models/gorubi_models.py

@@ -1,255 +0,0 @@
-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

@@ -1,24 +0,0 @@
-\ 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

@@ -1,104 +0,0 @@
-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

@@ -3,10 +3,10 @@ import os
 import gradio as gr
 import pandas as pd
 
-from models.gurobi_models import solve_plne, solve_refinery_optimization
-from ui.gradio_sections import oil_refinery_tab, project_info_tab, vehicle_routing_tab
+from models.gurobi_models import solve_diet_problem, solve_plne
+from ui.gradio_sections import diet_problem_tab, project_info_tab, vehicle_routing_tab
 
-# Mock Data
+# Mock Data for Vehicle Routing Problem
 plne_df = pd.DataFrame(
     [
         {"Node": 0, "X": 50, "Y": 50, "Demand": 0},
@@ -18,91 +18,16 @@ plne_df = pd.DataFrame(
     ]
 )
 
-# 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},
-    ]
-)
-
-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
+diet_description = """
+### 🍎 Diet 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.
+Find the optimal diet that minimizes cost while meeting nutritional requirements.
 """
 
 # Read and encode the PDF - go up one directory to find assets at project root
@@ -123,14 +48,7 @@ with gr.Blocks(title="Operations Research App") as ro_app:
     )
     with gr.Tabs():
         project_info_tab()
-        oil_refinery_tab(
-            crude_df,
-            product_df,
-            yields_df,
-            quality_reqs_df,
-            solve_refinery_optimization,
-            refinery_description,
-        )
+        diet_problem_tab(solve_diet_problem, diet_description)
         vehicle_routing_tab(plne_df, solve_plne, plne_description)
 
 if __name__ == "__main__":

assets/compte_rendu.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bf8d44f9e66c0cc7ad70d4875ccaa43ea0a489366c3626733d03d6b4259cdef6
-size 1506148
+oid sha256:232255ba8666363b58f53a53eaed299529b2428a0863e647a42af720dcc50517
+size 1218613

models/gurobi_models.py

@@ -4,244 +4,486 @@ import matplotlib.pyplot as plt
 import pandas as pd
 from gurobipy import GRB, Model, quicksum
 
-import achref.src.logger as logger
+import utils.logger as logger
 
 logger = logger.get_logger(__name__)
 
 
-def solve_refinery_optimization(
-    crude_data, product_data, crude_product_yields, product_quality_reqs
-):
+def solve_diet_problem(foods_df, requirements_df):
     """
-    Solves the Oil Refinery Optimization Problem.
+    Solves the Diet Problem using Linear Programming with flexible number of foods and nutrients.
 
     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"]
+        foods_df (pd.DataFrame): DataFrame with columns ['Food', 'Cost'] + nutrient columns
+        requirements_df (pd.DataFrame): DataFrame with columns ['Nutrient', 'Minimum']
 
     Returns:
         tuple: (result_df, fig) where result_df contains the optimal solution and fig is a matplotlib figure
+
+    Raises:
+        TypeError: If inputs are not DataFrames or contain invalid data types
+        ValueError: If data validation fails or optimization problem cannot be solved
+        Exception: If Gurobi solver encounters an error
     """
-    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 Diet Problem")
 
-    logger.info("Starting Gurobi model for Oil Refinery Optimization")
+    try:
+        # Type validation
+        if not isinstance(foods_df, pd.DataFrame):
+            raise TypeError("foods_df must be a pandas DataFrame")
+        if not isinstance(requirements_df, pd.DataFrame):
+            raise TypeError("requirements_df must be a pandas DataFrame")
+
+        # Empty data validation
+        if foods_df.empty:
+            raise ValueError(
+                "Foods data cannot be empty. Please provide at least one food item."
+            )
+        if requirements_df.empty:
+            raise ValueError(
+                "Requirements data cannot be empty. Please provide at least one nutritional requirement."
+            )
 
-    # Create optimization model
-    model = Model("OilRefineryOptimization")
-    model.setParam("OutputFlag", 0)
+        # Required columns validation
+        required_food_cols = {"Food", "Cost"}
+        if not required_food_cols.issubset(foods_df.columns):
+            missing = required_food_cols - set(foods_df.columns)
+            raise ValueError(
+                f"Missing required columns in foods data: {missing}. Required columns: {required_food_cols}"
+            )
 
-    # Get unique crudes and products
-    crudes = crude_data["Crude"].unique().tolist()
-    products = product_data["Product"].unique().tolist()
+        required_req_cols = {"Nutrient", "Minimum"}
+        if not required_req_cols.issubset(requirements_df.columns):
+            missing = required_req_cols - set(requirements_df.columns)
+            raise ValueError(
+                f"Missing required columns in requirements data: {missing}. Required columns: {required_req_cols}"
+            )
 
-    # 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()
-    }
+        # Duplicate validation
+        if foods_df["Food"].duplicated().any():
+            duplicates = foods_df[foods_df["Food"].duplicated()]["Food"].tolist()
+            raise ValueError(
+                f"Duplicate food names found: {duplicates}. Each food must have a unique name."
+            )
 
-    # 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
-        )
+        if requirements_df["Nutrient"].duplicated().any():
+            duplicates = requirements_df[requirements_df["Nutrient"].duplicated()][
+                "Nutrient"
+            ].tolist()
+            raise ValueError(
+                f"Duplicate nutrient names found: {duplicates}. Each nutrient must be unique."
+            )
 
-    # 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)
+        # Get nutrient columns (all columns except 'Food' and 'Cost')
+        nutrient_cols = [col for col in foods_df.columns if col not in ["Food", "Cost"]]
 
-    # Constraints:
+        if not nutrient_cols:
+            raise ValueError(
+                "No nutrient columns found in foods data. Please include at least one nutrient column (e.g., 'Protein', 'Fat', 'Carbs')."
+            )
 
-    # 1. Crude availability constraints
-    for crude in crudes:
-        model.addConstr(x[crude] <= availability[crude], name=f"avail_{crude}")
+        # Data type validation
+        try:
+            foods_df["Cost"] = pd.to_numeric(foods_df["Cost"], errors="raise")
+        except (ValueError, TypeError) as e:
+            raise ValueError(
+                f"Cost column contains non-numeric values. All costs must be numbers. Error: {str(e)}"
+            )
 
-    # 2. Demand satisfaction constraints
-    for product in products:
-        model.addConstr(
-            total_production[product] >= demands[product], name=f"demand_{product}"
-        )
+        try:
+            requirements_df["Minimum"] = pd.to_numeric(
+                requirements_df["Minimum"], errors="raise"
+            )
+        except (ValueError, TypeError) as e:
+            raise ValueError(
+                f"Minimum column contains non-numeric values. All requirements must be numbers. Error: {str(e)}"
+            )
 
-    # 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
+        for col in nutrient_cols:
+            try:
+                foods_df[col] = pd.to_numeric(foods_df[col], errors="raise")
+            except (ValueError, TypeError) as e:
+                raise ValueError(
+                    f"Nutrient column '{col}' contains non-numeric values. All nutrient values must be numbers. Error: {str(e)}"
+                )
+
+        # Value range validation
+        if (foods_df["Cost"] < 0).any():
+            negative_costs = foods_df[foods_df["Cost"] < 0]["Food"].tolist()
+            raise ValueError(
+                f"Negative costs found for foods: {negative_costs}. All costs must be non-negative."
             )
-            model.addConstr(
-                quality_numerator >= min_qualities[product] * total_production[product],
-                name=f"quality_{product}",
+
+        if (requirements_df["Minimum"] <= 0).any():
+            non_positive_reqs = requirements_df[requirements_df["Minimum"] <= 0][
+                "Nutrient"
+            ].tolist()
+            raise ValueError(
+                f"Non-positive requirements found for nutrients: {non_positive_reqs}. All requirements must be positive."
             )
 
-    # Solve the model
-    model.optimize()
+        for col in nutrient_cols:
+            if (foods_df[col] < 0).any():
+                negative_nutrients = foods_df[foods_df[col] < 0]["Food"].tolist()
+                raise ValueError(
+                    f"Negative {col} values found for foods: {negative_nutrients}. All nutrient values must be non-negative."
+                )
+
+        # Check if any required nutrient is missing from foods data
+        missing_nutrients = set(requirements_df["Nutrient"]) - set(nutrient_cols)
+        if missing_nutrients:
+            raise ValueError(
+                f"Required nutrients missing from foods data: {missing_nutrients}. Please add these nutrient columns to your foods data."
+            )
 
-    # Check if optimal solution was found
-    if model.status != GRB.OPTIMAL:
-        raise ValueError("Failed to find an optimal solution")
+        # Check for zero costs (potential unbounded solution)
+        if (foods_df["Cost"] == 0).any():
+            zero_cost_foods = foods_df[foods_df["Cost"] == 0]["Food"].tolist()
+            logger.warning(
+                f"Foods with zero cost detected: {zero_cost_foods}. This may lead to unrealistic solutions."
+            )
 
-    # Extract results
-    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],
-        }
-    )
+        # Feasibility pre-check: ensure at least one food provides each required nutrient
+        for _, req_row in requirements_df.iterrows():
+            nutrient = req_row["Nutrient"]
+            if nutrient in nutrient_cols:
+                max_nutrient = foods_df[nutrient].max()
+                if max_nutrient == 0:
+                    raise ValueError(
+                        f"No food provides the required nutrient '{nutrient}'. Problem is infeasible."
+                    )
+                if max_nutrient < req_row["Minimum"]:
+                    logger.warning(
+                        f"Maximum {nutrient} content ({max_nutrient}) is less than requirement ({req_row['Minimum']}). May need multiple foods."
+                    )
 
-    # 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
+    except Exception as e:
+        logger.error(f"Data validation failed: {str(e)}")
+        raise
 
-        prod_results.append(
-            {
-                "Product": product,
-                "Amount Produced": prod_amount,
-                "Revenue": revenue,
-                "Average Quality": avg_quality,
-                "Min Quality Required": min_qualities.get(product, "N/A"),
-            }
+    # Create optimization model
+    try:
+        model = Model("DietProblem")
+        model.setParam("OutputFlag", 0)
+
+        # Set time limit to prevent infinite solving (60 seconds)
+        model.setParam("TimeLimit", 60)
+
+        logger.info("Creating decision variables...")
+
+        # Decision variables: units of each food
+        food_vars = {}
+        for i, food_name in enumerate(foods_df["Food"]):
+            if pd.isna(food_name) or str(food_name).strip() == "":
+                raise ValueError(
+                    f"Empty or invalid food name at row {i}. All foods must have valid names."
+                )
+            food_vars[food_name] = model.addVar(name=f"Food_{i}_{food_name}", lb=0)
+
+        logger.info("Setting objective function...")
+
+        # Objective: Minimize total cost
+        model.setObjective(
+            quicksum(
+                foods_df.loc[foods_df["Food"] == food, "Cost"].iloc[0] * var
+                for food, var in food_vars.items()
+            ),
+            GRB.MINIMIZE,
         )
 
-    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"
-    )
+        logger.info("Adding constraints...")
+
+        # Constraints: Nutritional requirements
+        for _, req_row in requirements_df.iterrows():
+            nutrient = req_row["Nutrient"]
+            min_requirement = req_row["Minimum"]
+
+            if pd.isna(nutrient) or str(nutrient).strip() == "":
+                raise ValueError(
+                    "Empty or invalid nutrient name found. All nutrients must have valid names."
+                )
+
+            if nutrient in nutrient_cols:
+                model.addConstr(
+                    quicksum(
+                        foods_df.loc[foods_df["Food"] == food, nutrient].iloc[0] * var
+                        for food, var in food_vars.items()
+                    )
+                    >= min_requirement,
+                    name=f"{nutrient}_requirement",
+                )
+            else:
+                logger.warning(
+                    f"Nutrient '{nutrient}' not found in foods data. Skipping constraint."
+                )
+
+        logger.info("Solving optimization model...")
+
+        # Solve the model
+        model.optimize()
+
+        # Enhanced status checking
+        if model.status == GRB.OPTIMAL:
+            logger.info("Optimal solution found successfully")
+        elif model.status == GRB.INFEASIBLE:
+            logger.error("Problem is infeasible")
+            # Try to compute IIS (Irreducible Inconsistent Subsystem) for debugging
+            try:
+                model.computeIIS()
+                iis_constraints = []
+                for constr in model.getConstrs():
+                    if constr.IISConstr:
+                        iis_constraints.append(constr.ConstrName)
+                if iis_constraints:
+                    raise ValueError(
+                        f"Problem is infeasible. Conflicting constraints: {iis_constraints}. Try reducing requirements or adding more diverse foods."
+                    )
+                else:
+                    raise ValueError(
+                        "Problem is infeasible. The nutritional requirements cannot be met with the provided foods. Try reducing requirements or adding more foods with different nutritional profiles."
+                    )
+            except Exception as iis_error:
+                logger.warning(f"Could not compute IIS: {str(iis_error)}")
+                raise ValueError(
+                    "Problem is infeasible. The nutritional requirements cannot be met with the provided foods. Try reducing requirements or adding more diverse foods."
+                )
+        elif model.status == GRB.UNBOUNDED:
+            logger.error("Problem is unbounded")
+            raise ValueError(
+                "Problem is unbounded. This usually occurs when some foods have zero cost. Please ensure all foods have positive costs."
+            )
+        elif model.status == GRB.TIME_LIMIT:
+            logger.error("Time limit reached")
+            raise ValueError(
+                "Solver time limit reached (60 seconds). The problem may be too complex. Try simplifying the problem or contact support."
+            )
+        elif model.status == GRB.INTERRUPTED:
+            logger.error("Solver was interrupted")
+            raise ValueError("Solver was interrupted. Please try again.")
+        elif model.status == GRB.NUMERIC:
+            logger.error("Numerical difficulties encountered")
+            raise ValueError(
+                "Numerical difficulties encountered. Try using simpler numbers or scaling your data."
+            )
+        else:
+            logger.error(f"Unexpected solver status: {model.status}")
+            raise ValueError(
+                f"Failed to find an optimal solution. Solver status: {model.status}. Please check your input data."
+            )
 
-    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")
+    except Exception as gurobi_error:
+        logger.error(f"Gurobi optimization error: {str(gurobi_error)}")
+        if "Gurobi" in str(type(gurobi_error)):
+            raise ValueError(
+                f"Gurobi solver error: {str(gurobi_error)}. Please check your Gurobi installation and license."
+            )
+        else:
+            raise
 
-    fig.tight_layout()
+    # Extract results
+    try:
+        total_cost = model.objVal
+        logger.info(f"Optimal solution found with total cost: {total_cost:.2f}")
+
+        # Create results dataframe
+        result_rows = []
+        for food_name, var in food_vars.items():
+            try:
+                food_row = foods_df[foods_df["Food"] == food_name].iloc[0]
+                amount = var.X
+
+                result_row = {
+                    "Food": food_name,
+                    "Units": amount,
+                    "Cost": food_row["Cost"] * amount,
+                }
+
+                # Add nutrient contributions
+                for nutrient in nutrient_cols:
+                    result_row[nutrient] = food_row[nutrient] * amount
+
+                result_rows.append(result_row)
+            except Exception as extract_error:
+                logger.error(
+                    f"Error extracting results for food '{food_name}': {str(extract_error)}"
+                )
+                raise ValueError(
+                    f"Error processing results for food '{food_name}': {str(extract_error)}"
+                )
+
+        result_df = pd.DataFrame(result_rows)
+
+        # Validate results
+        if result_df.empty:
+            raise ValueError(
+                "No results generated. This is unexpected after finding an optimal solution."
+            )
 
-    # Combine results for return
-    combined_results = {
-        "Crude Usage": crude_results,
-        "Product Production": product_results_df,
-        "Total Profit": profit,
-    }
+        # Check if any solution violates non-negativity (shouldn't happen, but good to check)
+        if (result_df["Units"] < -1e-6).any():
+            negative_foods = result_df[result_df["Units"] < -1e-6]["Food"].tolist()
+            logger.warning(
+                f"Negative amounts found for foods (numerical error): {negative_foods}"
+            )
+            # Clamp negative values to zero
+            result_df["Units"] = result_df["Units"].clip(lower=0)
 
-    # 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],
-        }
-    )
+    except Exception as result_error:
+        logger.error(f"Error extracting optimization results: {str(result_error)}")
+        raise ValueError(
+            f"Failed to extract optimization results: {str(result_error)}"
+        )  # Create flexible visualizations
+    try:
+        fig, axs = plt.subplots(2, 2, figsize=(14, 10))
+        fig.suptitle("Diet Problem Optimization Results", fontsize=16, y=1.02)
+
+        # Plot 1: Food Units - only show foods with positive amounts
+        foods_with_amounts = result_df[result_df["Units"] > 0.001]
+        if not foods_with_amounts.empty:
+            colors = plt.cm.Set3(range(len(foods_with_amounts)))
+            axs[0, 0].bar(
+                foods_with_amounts["Food"], foods_with_amounts["Units"], color=colors
+            )
+            axs[0, 0].set_title("Optimal Food Quantities")
+            axs[0, 0].set_ylabel("Units")
+            axs[0, 0].tick_params(axis="x", rotation=45)
+        else:
+            axs[0, 0].text(
+                0.5,
+                0.5,
+                "No foods selected\n(all amounts are zero)",
+                ha="center",
+                va="center",
+                transform=axs[0, 0].transAxes,
+            )
+            axs[0, 0].set_title("Optimal Food Quantities")
 
-    return product_results_df, fig
+        # Plot 2: Cost Breakdown
+        if not foods_with_amounts.empty:
+            axs[0, 1].bar(
+                foods_with_amounts["Food"], foods_with_amounts["Cost"], color=colors
+            )
+            axs[0, 1].set_title("Cost per Food Type")
+            axs[0, 1].set_ylabel("Cost ($)")
+            axs[0, 1].tick_params(axis="x", rotation=45)
+        else:
+            axs[0, 1].text(
+                0.5,
+                0.5,
+                "No costs to display",
+                ha="center",
+                va="center",
+                transform=axs[0, 1].transAxes,
+            )
+            axs[0, 1].set_title("Cost per Food Type")
+
+        # Plot 3: Nutritional Requirements vs Achieved
+        achieved_nutrients = {}
+        for nutrient in nutrient_cols:
+            achieved_nutrients[nutrient] = result_df[nutrient].sum()
+
+        requirements_dict = dict(
+            zip(requirements_df["Nutrient"], requirements_df["Minimum"])
+        )
+
+        nutrients = list(nutrient_cols)
+        requirements = [requirements_dict.get(nut, 0) for nut in nutrients]
+        achieved = [achieved_nutrients.get(nut, 0) for nut in nutrients]
+
+        if nutrients:
+            x_pos = range(len(nutrients))
+            width = 0.35
+            axs[1, 0].bar(
+                [i - width / 2 for i in x_pos],
+                requirements,
+                width,
+                label="Required",
+                color="red",
+                alpha=0.7,
+            )
+            axs[1, 0].bar(
+                [i + width / 2 for i in x_pos],
+                achieved,
+                width,
+                label="Achieved",
+                color="green",
+                alpha=0.7,
+            )
+            axs[1, 0].set_title("Nutritional Requirements vs Achieved")
+            axs[1, 0].set_ylabel("Units")
+            axs[1, 0].set_xticks(x_pos)
+            axs[1, 0].set_xticklabels(nutrients, rotation=45)
+            axs[1, 0].legend()
+        else:
+            axs[1, 0].text(
+                0.5,
+                0.5,
+                "No nutrients to display",
+                ha="center",
+                va="center",
+                transform=axs[1, 0].transAxes,
+            )
+            axs[1, 0].set_title("Nutritional Requirements vs Achieved")
+
+        # Plot 4: Summary Information
+        summary_data = [("Total Cost", total_cost)]
+        for nutrient in nutrient_cols:
+            summary_data.append(
+                (f"Total {nutrient}", achieved_nutrients.get(nutrient, 0))
+            )
+
+        if summary_data:
+            summary_labels, summary_values = zip(*summary_data)
+            colors_summary = plt.cm.viridis(range(len(summary_data)))
+
+            bars = axs[1, 1].bar(summary_labels, summary_values, color=colors_summary)
+            axs[1, 1].set_title("Diet Summary")
+            axs[1, 1].set_ylabel("Value")
+
+            # Add value labels on bars
+            for bar, value in zip(bars, summary_values):
+                height = bar.get_height()
+                axs[1, 1].text(
+                    bar.get_x() + bar.get_width() / 2.0,
+                    height + max(summary_values) * 0.01,
+                    f"{value:.2f}",
+                    ha="center",
+                    va="bottom",
+                    fontsize=8,
+                )
+            axs[1, 1].tick_params(axis="x", rotation=45)
+        else:
+            axs[1, 1].text(
+                0.5,
+                0.5,
+                "No summary data to display",
+                ha="center",
+                va="center",
+                transform=axs[1, 1].transAxes,
+            )
+            axs[1, 1].set_title("Diet Summary")
+
+        fig.tight_layout()
+
+        logger.info("Visualization created successfully")
+
+    except Exception as plot_error:
+        logger.error(f"Error creating visualization: {str(plot_error)}")
+        # Create a simple fallback plot
+        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
+        ax.text(
+            0.5,
+            0.5,
+            f"Visualization Error\nOptimal Cost: ${total_cost:.2f}\nSee results table for details",
+            ha="center",
+            va="center",
+            transform=ax.transAxes,
+            fontsize=12,
+        )
+        ax.set_title("Diet Problem Results")
+        ax.axis("off")
+
+    return result_df, fig
 
 
 def _validate_plne_input(data, vehicle_capacity, num_vehicles):
@@ -553,4 +795,4 @@ def solve_plne(data: pd.DataFrame, vehicle_capacity: float, num_vehicles: int):
     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}")
+        raise RuntimeError(f"Unexpected error in solve_plne: {e}")

requirements.txt

@@ -7,6 +7,7 @@ charset-normalizer==3.4.2
 click==8.1.8
 contourpy==1.3.2
 cycler==0.12.1
+dotenv==0.9.9
 fastapi==0.115.12
 ffmpy==0.5.0
 filelock==3.18.0
@@ -41,6 +42,7 @@ pydub==0.25.1
 Pygments==2.19.1
 pyparsing==3.2.3
 python-dateutil==2.9.0.post0
+python-dotenv==1.1.0
 python-multipart==0.0.20
 pytz==2025.2
 PyYAML==6.0.2

ui/gradio_sections.py

@@ -4,7 +4,7 @@ import os
 import gradio as gr
 import pandas as pd
 
-import achref.src.logger as logger
+import utils.logger as logger
 
 logger = logger.get_logger(__name__)
 
@@ -13,21 +13,68 @@ def project_info_tab():
     with gr.Tab("\U0001f4d8 Project Info"):
         gr.Markdown(
             """
-        # \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**.
-        
-        ---
-        # \U0001f465 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  
-        ---
-        # \U0001f9fe Compte Rendu
-        """
+            # \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**.
+            """
+        )
+
+        gr.HTML(
+            """
+            <style>
+                .member-card {
+                    display: flex;
+                    flex-direction: column;
+                    align-items: center;
+                    width: 160px;
+                    text-align: center;
+                    margin: 10px;
+                }
+                .member-card img {
+                    width: 120px;
+                    height: 140px;
+                    object-fit: cover;
+                    border-radius: 8px;
+                    border: 1px solid #ccc;
+                }
+                .member-name {
+                    margin-top: 8px;
+                    font-weight: bold;
+                }
+            </style>
+            <div style="display: flex; flex-wrap: wrap; justify-content: center;">
+                <div class="member-card">
+                    <img src="https://raw.githubusercontent.com/KacemMathlouthi/OperationsResearch/main/assets/images/kacem_mathlouthi.jpg" alt="Kacem Mathlouthi">
+                    <div class="member-name">Kacem Mathlouthi</div>
+                </div>
+                <div class="member-card">
+                    <img src="https://raw.githubusercontent.com/KacemMathlouthi/OperationsResearch/main/assets/images/mohamed_amine_haouas.jpg" alt="Mohamed Amine Houas">
+                    <div class="member-name">Mohamed Amine Houas</div>
+                </div>
+                <div class="member-card">
+                    <img src="https://raw.githubusercontent.com/KacemMathlouthi/OperationsResearch/main/assets/images/oussema_kraiem.jpg" alt="Oussema Kraiem">
+                    <div class="member-name">Oussema Kraiem</div>
+                </div>
+                <div class="member-card">
+                    <img src="https://raw.githubusercontent.com/KacemMathlouthi/OperationsResearch/main/assets/images/mohamed_yassine_taieb.jpg" alt="Yassine Taieb">
+                    <div class="member-name">Yassine Taieb</div>
+                </div>
+                <div class="member-card">
+                    <img src="https://raw.githubusercontent.com/KacemMathlouthi/OperationsResearch/main/assets/images/youssef_sghairi.jpg" alt="Youssef Sghairi">
+                    <div class="member-name">Youssef Sghairi</div>
+                </div>
+                <div class="member-card">
+                    <img src="https://raw.githubusercontent.com/KacemMathlouthi/OperationsResearch/main/assets/images/youssef_aridhi.jpg" alt="Youssef Aaridhi">
+                    <div class="member-name">Youssef Aaridhi</div>
+                </div>
+            </div>
+            """
+        )
+
+        gr.Markdown(
+            """
+            ---
+            # \U0001f9fe Compte Rendu
+            """
         )
         pdf_path = os.path.join(
             os.path.dirname(os.path.dirname(__file__)), "assets", "compte_rendu.pdf"
@@ -43,116 +90,323 @@ def project_info_tab():
         )
 
 
-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)
+def diet_problem_tab(solve_diet_problem, diet_description):
+    with gr.Tab("🍎 Diet Problem (PL)"):
+        gr.Markdown(diet_description)
 
         # Add mathematical model description
         gr.Markdown(
             r"""
             ### 🧮 Mathematical Formulation
 
-            **Sets and Indices**
-            | Symbol      | Description                             |
-            |-------------|-----------------------------------------|
-            | $$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$ |
+            | Symbol      | Description                                    |
+            |-------------|------------------------------------------------|
+            | $$I$$       | Set of available foods                         |
+            | $$J$$       | Set of nutrients                               |
+            | $$c_i$$     | Cost per unit of food i                        |
+            | $$n_{ij}$$  | Amount of nutrient j in one unit of food i     |
+            | $$R_j$$     | Minimum requirement for nutrient j             |
 
             **Decision Variables**
             | Symbol      | Description                             |
             |-------------|-----------------------------------------|
-            | $$x_i$$       | Amount of crude oil $i$ used (liters) |
+            | $$x_i$$     | Units of food i to consume     |
 
-            **Objective:**  
+            **Objective Function:**  
             $$
-            \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)
+            \text{Minimize} \quad Z = \sum_{i \in I} c_i \cdot x_i
             $$
 
             **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$$
+            1. **Nutritional requirements:**
+            $$\sum_{i \in I} n_{ij} \cdot x_i \geq R_j \quad \forall j \in J$$
 
-            4. Non-negativity:
-            $$x_i \geq 0 \quad \forall i$$
+            2. **Non-negativity:**
+            $$x_i \geq 0 \quad \forall i \in I$$
             """
         )
 
-        with gr.Tabs():
-            with gr.TabItem("Crude Oils"):
-                crude_input = gr.Dataframe(
-                    headers=["Crude", "Cost", "Availability"],
-                    value=mock_crude_data,
-                    label="Crude Oil Data",
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 🍎 Foods Data")
+                gr.Markdown(
+                    "Add foods with their costs and nutritional content per unit:"
+                )
+
+                # Default foods data
+                default_foods = pd.DataFrame(
+                    [
+                        {"Food": "Food A", "Cost": 3.0, "Protein": 2.0, "Fat": 1.0},
+                        {"Food": "Food B", "Cost": 2.0, "Protein": 1.0, "Fat": 2.0},
+                    ]
                 )
 
-            with gr.TabItem("Products"):
-                product_input = gr.Dataframe(
-                    headers=["Product", "Price", "Demand"],
-                    value=mock_product_data,
-                    label="Product Data",
+                foods_input = gr.Dataframe(
+                    value=default_foods,
+                    headers=["Food", "Cost", "Protein", "Fat"],
+                    datatype=["str", "number", "number", "number"],
+                    col_count=(4, "dynamic"),
+                    row_count=(2, "dynamic"),
+                    label="Foods and Nutritional Content",
+                    interactive=True,
                 )
 
-            with gr.TabItem("Yields & Quality"):
-                yields_input = gr.Dataframe(
-                    headers=["Crude", "Product", "Yield", "Quality"],
-                    value=mock_yields_data,
-                    label="Yield & Quality Data",
+            with gr.Column():
+                gr.Markdown("### 🥗 Nutritional Requirements")
+                gr.Markdown("Specify minimum daily requirements for each nutrient:")
+
+                # Default requirements data
+                default_requirements = pd.DataFrame(
+                    [
+                        {"Nutrient": "Protein", "Minimum": 8.0},
+                        {"Nutrient": "Fat", "Minimum": 6.0},
+                    ]
                 )
 
-            with gr.TabItem("Quality Requirements"):
-                quality_reqs_input = gr.Dataframe(
-                    headers=["Product", "MinQuality"],
-                    value=mock_quality_reqs,
-                    label="Quality Requirements",
+                requirements_input = gr.Dataframe(
+                    value=default_requirements,
+                    headers=["Nutrient", "Minimum"],
+                    datatype=["str", "number"],
+                    col_count=(2, "fixed"),
+                    row_count=(2, "dynamic"),
+                    label="Nutritional Requirements",
+                    interactive=True,
                 )
 
-        solve_btn = gr.Button("Solve Refinery Optimization Problem")
+        solve_btn = gr.Button("Solve Diet Problem", variant="primary")
         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):
+        def _solve_diet_optimization(foods_df, requirements_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
+                logger.info("Starting diet optimization from UI")
+
+                # Input existence validation
+                if foods_df is None or len(foods_df) == 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        "❌ Error: Please provide foods data. Add at least one food item with its cost and nutritional content.",
+                    )
+
+                if requirements_df is None or len(requirements_df) == 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        "❌ Error: Please provide requirements data. Add at least one nutritional requirement.",
+                    )
+
+                # Convert to DataFrame if needed
+                if not isinstance(foods_df, pd.DataFrame):
+                    try:
+                        foods_df = pd.DataFrame(foods_df)
+                    except Exception as e:
+                        return (
+                            pd.DataFrame(),
+                            None,
+                            f"❌ Error: Cannot convert foods data to DataFrame: {str(e)}",
+                        )
+
+                if not isinstance(requirements_df, pd.DataFrame):
+                    try:
+                        requirements_df = pd.DataFrame(requirements_df)
+                    except Exception as e:
+                        return (
+                            pd.DataFrame(),
+                            None,
+                            f"❌ Error: Cannot convert requirements data to DataFrame: {str(e)}",
+                        )
+
+                # Remove completely empty rows
+                foods_df = foods_df.dropna(how="all")
+                requirements_df = requirements_df.dropna(how="all")
+
+                # Check if data still exists after cleaning
+                if foods_df.empty:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        "❌ Error: No valid foods data found. Please ensure at least one row has valid data.",
+                    )
+
+                if requirements_df.empty:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        "❌ Error: No valid requirements data found. Please ensure at least one row has valid data.",
+                    )
+
+                # Validate required columns
+                if "Food" not in foods_df.columns or "Cost" not in foods_df.columns:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        "❌ Error: Foods data must have 'Food' and 'Cost' columns. Please check your column headers.",
+                    )
+
+                if (
+                    "Nutrient" not in requirements_df.columns
+                    or "Minimum" not in requirements_df.columns
+                ):
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        "❌ Error: Requirements data must have 'Nutrient' and 'Minimum' columns. Please check your column headers.",
+                    )
+
+                # Check for missing values in critical columns
+                missing_food_names = foods_df["Food"].isna().sum()
+                if missing_food_names > 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: {missing_food_names} food(s) have missing names. All foods must have valid names.",
+                    )
+
+                missing_costs = foods_df["Cost"].isna().sum()
+                if missing_costs > 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: {missing_costs} food(s) have missing costs. All foods must have valid costs.",
+                    )
+
+                missing_nutrients = requirements_df["Nutrient"].isna().sum()
+                if missing_nutrients > 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: {missing_nutrients} requirement(s) have missing nutrient names. All requirements must have valid nutrient names.",
+                    )
+
+                missing_minimums = requirements_df["Minimum"].isna().sum()
+                if missing_minimums > 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: {missing_minimums} requirement(s) have missing minimum values. All requirements must have valid minimum values.",
+                    )
+
+                # Check for negative values
+                try:
+                    numeric_cols = foods_df.select_dtypes(include=[float, int]).columns
+                    numeric_cols = [
+                        col for col in numeric_cols if col != "Food"
+                    ]  # Exclude non-numeric columns
+
+                    if (
+                        len(numeric_cols) > 0
+                        and (foods_df[numeric_cols] < 0).any().any()
+                    ):
+                        negative_foods = []
+                        for col in numeric_cols:
+                            if (foods_df[col] < 0).any():
+                                bad_foods = foods_df[foods_df[col] < 0]["Food"].tolist()
+                                negative_foods.extend(
+                                    [f"{food} ({col})" for food in bad_foods]
+                                )
+
+                        return (
+                            pd.DataFrame(),
+                            None,
+                            f"❌ Error: Negative values found: {', '.join(negative_foods[:5])}{'...' if len(negative_foods) > 5 else ''}. All numeric values must be non-negative.",
+                        )
+                except Exception as numeric_error:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: Problem checking numeric values: {str(numeric_error)}. Please ensure all numeric columns contain valid numbers.",
+                    )
+
+                try:
+                    if (requirements_df["Minimum"] <= 0).any():
+                        bad_requirements = requirements_df[
+                            requirements_df["Minimum"] <= 0
+                        ]["Nutrient"].tolist()
+                        return (
+                            pd.DataFrame(),
+                            None,
+                            f"❌ Error: Non-positive requirements found for: {', '.join(bad_requirements)}. All requirements must be positive values.",
+                        )
+                except Exception as req_error:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: Problem checking requirements: {str(req_error)}. Please ensure all requirement values are positive numbers.",
+                    )
+
+                # Check for empty strings in food names
+                empty_food_names = foods_df[
+                    foods_df["Food"].astype(str).str.strip() == ""
+                ]["Food"].count()
+                if empty_food_names > 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: {empty_food_names} food(s) have empty names. All foods must have non-empty names.",
+                    )
+
+                # Check for empty strings in nutrient names
+                empty_nutrient_names = requirements_df[
+                    requirements_df["Nutrient"].astype(str).str.strip() == ""
+                ]["Nutrient"].count()
+                if empty_nutrient_names > 0:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        f"❌ Error: {empty_nutrient_names} nutrient(s) have empty names. All nutrients must have non-empty names.",
+                    )
+
+                logger.info("UI validation passed, calling solver...")
+                result_df, fig = solve_diet_problem(foods_df, requirements_df)
+
+                # Validate solver results
+                if result_df is None or result_df.empty:
+                    return (
+                        pd.DataFrame(),
+                        None,
+                        "❌ Error: Solver returned empty results. This is unexpected.",
+                    )
+
+                # Check if solution makes sense
+                total_cost = (
+                    result_df["Cost"].sum() if "Cost" in result_df.columns else 0
+                )
+                if total_cost < 0:
+                    logger.warning(f"Negative total cost detected: {total_cost}")
+
+                logger.info(
+                    f"Optimization completed successfully with total cost: {total_cost:.2f}"
+                )
+                return (
+                    result_df,
+                    fig,
+                    f"✅ Solved Successfully! Optimal diet plan found with total cost: ${total_cost:.2f}",
                 )
-                return result_df, fig, "Solved Successfully"
+
+            except ValueError as ve:
+                logger.error(f"Validation error: {str(ve)}")
+                return pd.DataFrame(), None, f"❌ Validation Error: {str(ve)}"
+            except TypeError as te:
+                logger.error(f"Type error: {str(te)}")
+                return pd.DataFrame(), None, f"❌ Data Type Error: {str(te)}"
             except Exception as e:
-                return pd.DataFrame(), None, f"❌ Error: {str(e)}"
+                logger.error(f"Unexpected error in diet optimization: {str(e)}")
+                error_msg = str(e)
+                if "Gurobi" in error_msg:
+                    return pd.DataFrame(), None, f"❌ Solver Error: {error_msg}"
+                elif "infeasible" in error_msg.lower():
+                    return pd.DataFrame(), None, f"❌ Infeasible Problem: {error_msg}"
+                elif "unbounded" in error_msg.lower():
+                    return pd.DataFrame(), None, f"❌ Unbounded Problem: {error_msg}"
+                else:
+                    return pd.DataFrame(), None, f"❌ Unexpected Error: {error_msg}"
 
         solve_btn.click(
-            fn=_solve_refinery_problem,
-            inputs=[crude_input, product_input, yields_input, quality_reqs_input],
+            fn=_solve_diet_optimization,
+            inputs=[foods_input, requirements_input],
             outputs=[results_table, results_plot, status_output],
         )
 
@@ -264,4 +518,4 @@ def vehicle_routing_tab(mock_plne_df, solve_plne, plne_description):
             fn=_solve_vrp_with_floats,
             inputs=[vrp_input, cap_input, k_input],
             outputs=[result_table, result_plot, status_output],
-        )
+        )

utils/__init__.py

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

{achref/src/logger → utils}/logger.py

@@ -9,7 +9,6 @@ from typing import Any, Callable
 load_dotenv()
 
 
-
 LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
 
 # Mapping of string levels to logging constants
@@ -18,33 +17,37 @@ LOG_LEVEL_MAPPING = {
     "INFO": logging.INFO,
     "WARNING": logging.WARNING,
     "ERROR": logging.ERROR,
-    "CRITICAL": logging.CRITICAL
+    "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
+            "DEBUG": "\033[34m",  # Blue
+            "INFO": "\033[32m",  # Green
             "WARNING": "\033[33m",  # Yellow
-            "ERROR": "\033[31m",    # Red
-            "CRITICAL": "\033[41m", # Red background
+            "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}"
+        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.
 
@@ -52,7 +55,7 @@ def get_logger(name: str) -> logging.Logger:
         name (str): name given to the logger
 
     Returns:
-        logging.Logger: logger object to be used for logging 
+        logging.Logger: logger object to be used for logging
     """
     # Create logger
     logger = logging.getLogger(name)
@@ -69,7 +72,7 @@ def get_logger(name: str) -> logging.Logger:
             "{asctime} | {levelname:<8} | {message}",
             style="{",
             datefmt="%Y-%m-%d %H:%M:%S",
-            use_colors=True
+            use_colors=True,
         )
 
         # Add formatter to the handler
@@ -80,26 +83,32 @@ def get_logger(name: str) -> logging.Logger:
 
     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}")
+            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