optimization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.optimize import minimize\n",
    "import tkinter as tk\n",
    "from tkinter import messagebox\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Define the objective function with checks to avoid division by zero\n",
    "def objective(x):\n",
    "    t, h, l, theta = x\n",
    "    epsilon = 1e-8  # Small value to prevent division by zero\n",
    "    numerator = 70000 * (t / l) ** 3 * np.cos(theta)\n",
    "    denominator = ((h / l) + np.sin(theta)) * (np.sin(theta) ** 2 + epsilon)\n",
    "    if denominator == 0:\n",
    "        return np.inf  # Avoid division by zero\n",
    "    return -numerator / denominator / 1e6  \n",
    "\n",
    "# Define the constraints\n",
    "def constraint1(x):\n",
    "    t, h, l, theta = x\n",
    "    return 0.033333 * h - t  \n",
    "\n",
    "def constraint2(x):\n",
    "    t, h, l, theta = x\n",
    "    return 0.1 * l - t  \n",
    "\n",
    "def constraint3(x):\n",
    "    t, h, l, theta = x\n",
    "    epsilon = 1e-8  # Small value to prevent division by zero\n",
    "    numerator = 2.7e-09 * ((2 + (h / l)) * t) / l\n",
    "    denominator = (2 * np.cos(theta)) * ((h / l) + np.sin(theta) + epsilon)\n",
    "    if denominator == 0:\n",
    "        return 100  # Avoid division by zero, ensure infeasibility\n",
    "    return 100 - (numerator / denominator)  # Constraint to be <= 100\n",
    "\n",
    "# Initial guess\n",
    "x0 = [0.7, 25.0, 25.0, 0.9]  # Adjusted to be within feasible region\n",
    "\n",
    "# Bounds for variables\n",
    "bounds = [(1, 50), (1, 50), (1, 10), (0.01, 1.6)]\n",
    "\n",
    "\n",
    "constraints = [\n",
    "    {'type': 'ineq', 'fun': constraint1},\n",
    "    {'type': 'ineq', 'fun': constraint2},\n",
    "    {'type': 'ineq', 'fun': constraint3}\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_optimization():\n",
    "    try:\n",
    "        # Retrieve bounds and initial guess from the GUI\n",
    "        t_lower = float(t_lower_entry.get())\n",
    "        t_upper = float(t_upper_entry.get())\n",
    "        h_lower = float(h_lower_entry.get())\n",
    "        h_upper = float(h_upper_entry.get())\n",
    "        l_lower = float(l_lower_entry.get())\n",
    "        l_upper = float(l_upper_entry.get())\n",
    "        theta_lower = float(theta_lower_entry.get())\n",
    "        theta_upper = float(theta_upper_entry.get())\n",
    "\n",
    "        initial_t = float(initial_t_entry.get())\n",
    "        initial_h = float(initial_h_entry.get())\n",
    "        initial_l = float(initial_l_entry.get())\n",
    "        initial_theta = float(initial_theta_entry.get())\n",
    "\n",
    "        # Set bounds for variables\n",
    "        bounds = [(t_lower, t_upper), (h_lower, h_upper), (l_lower, l_upper), (theta_lower, theta_upper)]\n",
    "\n",
    "        # Initial guess\n",
    "        x0 = [initial_t, initial_h, initial_l, initial_theta]\n",
    "\n",
    "        # Validate initial guess\n",
    "        initial_constraints = [constraint1(x0), constraint2(x0), constraint3(x0)]\n",
    "        print(f\"Initial guess: {x0}\")\n",
    "        print(f\"Initial constraints values: {initial_constraints}\")\n",
    "\n",
    "        if any(c < 0 for c in initial_constraints):\n",
    "            raise ValueError(\"Initial guess does not satisfy the constraints\")\n",
    "\n",
    "        # Solve the optimization problem using SLSQP\n",
    "        solution_slsqp = minimize(objective, x0, method='SLSQP', bounds=bounds, constraints=constraints, options={'disp': True})\n",
    "\n",
    "        # Solve the optimization problem using COBYLA\n",
    "        solution_cobyla = minimize(objective, x0, method='COBYLA', bounds=bounds, constraints=constraints, options={'disp': True})\n",
    "\n",
    "        # Compare and display results\n",
    "        if solution_slsqp.success:\n",
    "            print('SLSQP Solution:')\n",
    "            print(solution_slsqp.x)\n",
    "            print('SLSQP Objective value:')\n",
    "            print(-solution_slsqp.fun)\n",
    "        else:\n",
    "            print('SLSQP Optimization failed:')\n",
    "            print(solution_slsqp.message)\n",
    "\n",
    "        if solution_cobyla.success:\n",
    "            print('COBYLA Solution:')\n",
    "            print(solution_cobyla.x)\n",
    "            print('COBYLA Objective value:')\n",
    "            print(-solution_cobyla.fun)\n",
    "        else:\n",
    "            print('COBYLA Optimization failed:')\n",
    "            print(solution_cobyla.message)\n",
    "\n",
    "        if not solution_slsqp.success and not solution_cobyla.success:\n",
    "            raise ValueError(\"Both optimization methods failed\")\n",
    "\n",
    "    except Exception as e:\n",
    "        messagebox.showerror(\"Error\", str(e))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial guess: [0.7, 25.0, 25.0, 0.9]\n",
      "Initial constraints values: [0.13332500000000014, 1.8, np.float64(99.9999999998977)]\n",
      "Optimization terminated successfully    (Exit mode 0)\n",
      "            Current function value: -8.729171822067008e-07\n",
      "            Iterations: 1\n",
      "            Function evaluations: 5\n",
      "            Gradient evaluations: 1\n",
      "SLSQP Solution:\n",
      "[ 0.7 25.  25.   0.9]\n",
      "SLSQP Objective value:\n",
      "8.729171822067008e-07\n",
      "COBYLA Solution:\n",
      "[ 9.44959005e-01  2.83490536e+01  9.44959005e+00 -8.47032947e-26]\n",
      "COBYLA Objective value:\n",
      "2333.3100000000013\n"
     ]
    }
   ],
   "source": [
    "# Set up the GUI\n",
    "root = tk.Tk()\n",
    "root.title(\"Optimization\")\n",
    "\n",
    "# Define and place GUI elements\n",
    "tk.Label(root, text=\"t lower:\").grid(row=0, column=0)\n",
    "t_lower_entry = tk.Entry(root)\n",
    "t_lower_entry.grid(row=0, column=1)\n",
    "t_lower_entry.insert(0, \"0.1\")\n",
    "\n",
    "tk.Label(root, text=\"t upper:\").grid(row=1, column=0)\n",
    "t_upper_entry = tk.Entry(root)\n",
    "t_upper_entry.grid(row=1, column=1)\n",
    "t_upper_entry.insert(0, \"10\")\n",
    "\n",
    "tk.Label(root, text=\"h lower:\").grid(row=2, column=0)\n",
    "h_lower_entry = tk.Entry(root)\n",
    "h_lower_entry.grid(row=2, column=1)\n",
    "h_lower_entry.insert(0, \"1\")\n",
    "\n",
    "tk.Label(root, text=\"h upper:\").grid(row=3, column=0)\n",
    "h_upper_entry = tk.Entry(root)\n",
    "h_upper_entry.grid(row=3, column=1)\n",
    "h_upper_entry.insert(0, \"100\")\n",
    "\n",
    "tk.Label(root, text=\"l lower:\").grid(row=4, column=0)\n",
    "l_lower_entry = tk.Entry(root)\n",
    "l_lower_entry.grid(row=4, column=1)\n",
    "l_lower_entry.insert(0, \"1\")\n",
    "\n",
    "tk.Label(root, text=\"l upper:\").grid(row=5, column=0)\n",
    "l_upper_entry = tk.Entry(root)\n",
    "l_upper_entry.grid(row=5, column=1)\n",
    "l_upper_entry.insert(0, \"100\")\n",
    "\n",
    "tk.Label(root, text=\"theta lower:\").grid(row=6, column=0)\n",
    "theta_lower_entry = tk.Entry(root)\n",
    "theta_lower_entry.grid(row=6, column=1)\n",
    "theta_lower_entry.insert(0, \"0\")\n",
    "\n",
    "tk.Label(root, text=\"theta upper:\").grid(row=7, column=0)\n",
    "theta_upper_entry = tk.Entry(root)\n",
    "theta_upper_entry.grid(row=7, column=1)\n",
    "theta_upper_entry.insert(0, str(np.pi / 2))\n",
    "\n",
    "tk.Label(root, text=\"Initial t:\").grid(row=8, column=0)\n",
    "initial_t_entry = tk.Entry(root)\n",
    "initial_t_entry.grid(row=8, column=1)\n",
    "initial_t_entry.insert(0, \"0.7\")\n",
    "\n",
    "tk.Label(root, text=\"Initial h:\").grid(row=9, column=0)\n",
    "initial_h_entry = tk.Entry(root)\n",
    "initial_h_entry.grid(row=9, column=1)\n",
    "initial_h_entry.insert(0, \"25\")\n",
    "\n",
    "tk.Label(root, text=\"Initial l:\").grid(row=10, column=0)\n",
    "initial_l_entry = tk.Entry(root)\n",
    "initial_l_entry.grid(row=10, column=1)\n",
    "initial_l_entry.insert(0, \"25\")\n",
    "\n",
    "tk.Label(root, text=\"Initial theta:\").grid(row=11, column=0)\n",
    "initial_theta_entry = tk.Entry(root)\n",
    "initial_theta_entry.grid(row=11, column=1)\n",
    "initial_theta_entry.insert(0, \"0.9\")\n",
    "\n",
    "tk.Button(root, text=\"Run Optimization\", command=run_optimization).grid(row=12, column=0, columnspan=2)\n",
    "\n",
    "root.mainloop()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}