{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving Optimization Problems\n",
    "\n",
    "In this section, we explore how to solve an optimization problem \n",
    "once it has been defined, as outlined in the previous [section](./modeling.md).\n",
    "We can solve optimization problems using one of the optimization algorithms \n",
    "(also known as optimizers) from modOpt.\n",
    "Algorithms in modOpt are classified as either performant or educational algorithms.\n",
    "[Performant algorithms](./performant_algs.md) are popular, widely-used algorithms \n",
    "sourced from external libraries,\n",
    "while [educational algorithms](./educational_algs.md) are transparent algorithms fully implemented \n",
    "in modOpt, designed to support beginners and students learning optimization.\n",
    "Some of the performant algorithms are written in low-level languages such as C and Fortran.\n",
    "However, modOpt interfaces with these algorithms through precompiled sources,\n",
    "eliminating the challenges faced by users when compiling them locally on their computers.\n",
    "Educational algorithms, although primarily written in Python, are competitive with their\n",
    "performant counterparts on certain problems.\n",
    "\n",
    "## A simple way to solve a problem\n",
    "\n",
    "Unlike the educational algorithms, users have an easy, alternate way \n",
    "to optimize using the performant algorithms.\n",
    "This approach uses a minimal API that allows users to solve optimization problems using \n",
    "a single line of code once the problem is defined.\n",
    "To demonstrate this, we solve the simple optimization problem:\n",
    "\n",
    "$$\n",
    "\\underset{x_1, x_2 \\in \\mathbb{R}}{\\text{minimize}} \\quad x_1^2 + x_2^2\n",
    "\n",
    "\\newline\n",
    "\\text{subject to} \\quad x_1 \\geq 0\n",
    "\\newline\n",
    "\\quad \\quad \\quad \\quad x_1 + x_2 = 1\n",
    "\\newline\n",
    "\\quad \\quad \\quad \\quad x_1 - x_2 \\geq 1 \n",
    "$$\n",
    "\n",
    "In the code below, we use the `ProblemLite` class to model this problem.\n",
    "To learn more about other modeling options supported by modOpt, please visit\n",
    "the [Defining Optimization Problems](./modeling.md) section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/modopt/modopt/core/problem_lite.py:198: UserWarning: Objective Hessian function \"obj_hess\" not provided. Finite differences will be used if objective Hessian computation is necessary.\n",
      "  warnings.warn('Objective Hessian function \"obj_hess\" not provided. Finite differences will be used if objective Hessian computation is necessary.')\n",
      "/Users/modopt/modopt/core/problem_lite.py:209: UserWarning: Lagrangian Hessian function \"lag_hess\" not provided. Finite differences will be used if Lagrangian Hessian computation is necessary.\n",
      "  warnings.warn('Lagrangian Hessian function \"lag_hess\" not provided. Finite differences will be used if Lagrangian Hessian computation is necessary.')\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import modopt as mo\n",
    "\n",
    "x0 = np.array([50., 5.])            # initial guess\n",
    "xl = np.array([0., -np.inf])        # variable lower bounds\n",
    "cl = np.array([1., 1.])             # constraint lower bounds\n",
    "cu = np.array([1., np.inf])         # constraint upper bounds\n",
    "c_scaler = np.array([10., 100.])    # constraint scaler\n",
    "\n",
    "def obj(x):\n",
    "    return np.sum(x**2)\n",
    "def grad(x):    \n",
    "    return 2 * x\n",
    "def con(x):\n",
    "    return np.array([x[0] + x[1], x[0] - x[1]])\n",
    "def jac(x):\n",
    "    return np.array([[1., 1], [1., -1]])\n",
    "\n",
    "# Define the problem as a ProblemLite object \n",
    "# A ProblemLite object acts as a container for the problem constants, functions, and their derivatives\n",
    "problem = mo.ProblemLite(\n",
    "    x0, \n",
    "    obj=obj, \n",
    "    grad=grad, \n",
    "    con=con, \n",
    "    jac=jac, \n",
    "    cl=cl, \n",
    "    cu=cu,\n",
    "    xl=xl,\n",
    "    c_scaler = c_scaler,\n",
    "    name='constrained_quadratic'\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the problem object is defined and ready to be used by an optimizer,\n",
    "simply call the `optimize` function by specifying a `solver` and its configuration using `solver_options`.\n",
    "Here, we use the `SLSQP` optimizer with the options `maxiter` set to $100$ and `ftol` set to $1e-6$.\n",
    "This will run the optimizer and return the results in the form of a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          message: Optimization terminated successfully\n",
      "          success: True\n",
      "           status: 0\n",
      "              fun: 1.0000000000063949\n",
      "                x: [ 1.000e+00 -3.197e-12]\n",
      "              nit: 2\n",
      "              jac: [ 2.000e+00 -6.395e-12]\n",
      "             nfev: 2\n",
      "             njev: 2\n",
      "  total_callbacks: 9\n",
      "        obj_evals: 2\n",
      "       grad_evals: 2\n",
      "       hess_evals: 0\n",
      "        con_evals: 3\n",
      "        jac_evals: 2\n",
      " reused_callbacks: 0\n",
      "          out_dir: constrained_quadratic_outputs/2025-02-03_09.55.11.552413\n"
     ]
    }
   ],
   "source": [
    "results = mo.optimize(\n",
    "    problem, \n",
    "    solver='SLSQP', \n",
    "    solver_options={'maxiter': 100, 'ftol': 1e-6}\n",
    "    )\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## The standard way of solving problems in modOpt\n",
    "\n",
    "The standard and recommended way to optimize a problem is by directly using the\n",
    "optimizer class objects.\n",
    "This approach involves importing the optimizer of your choice from the library,\n",
    "setting tolerances and other parameters for the chosen optimizer, and finally solving the problem.\n",
    "Although slightly more verbose, using the optimizer classes can be more beneficial.\n",
    "It provides access to additional optimizer information and offers more debugging options,\n",
    "such as verifying the correctness of the user-provided first derivatives with the `check_first_derivatives` method.\n",
    "\n",
    "The following code optimizes the problem above using the same optimizer but follows the recommended approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "----------------------------------------------------------------------------\n",
      "Derivative type | Calc norm  | FD norm    | Abs error norm | Rel error norm \n",
      "----------------------------------------------------------------------------\n",
      "\n",
      "Gradient        | 1.0050e+02 | 1.0050e+02 | 1.2913e-06     | 1.2849e-08    \n",
      "Jacobian        | 1.4213e+02 | 1.4213e+02 | 1.0008e-06     | 7.0416e-09    \n",
      "----------------------------------------------------------------------------\n",
      "\n",
      "\n",
      "\tSolution from Scipy SLSQP:\n",
      "\t----------------------------------------------------------------------------------------------------\n",
      "\tProblem                  : constrained_quadratic\n",
      "\tSolver                   : scipy-slsqp\n",
      "\tSuccess                  : True\n",
      "\tMessage                  : Optimization terminated successfully\n",
      "\tStatus                   : 0\n",
      "\tTotal time               : 0.0024521350860595703\n",
      "\tObjective                : 1.0000000000063949\n",
      "\tGradient norm            : 2.000000000006395\n",
      "\tTotal function evals     : 2\n",
      "\tTotal gradient evals     : 2\n",
      "\tMajor iterations         : 2\n",
      "\tTotal callbacks          : 17\n",
      "\tReused callbacks         : 0\n",
      "\tobj callbacks            : 5\n",
      "\tgrad callbacks           : 3\n",
      "\thess callbacks           : 0\n",
      "\tcon callbacks            : 6\n",
      "\tjac callbacks            : 3\n",
      "\t----------------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Create an optimizer object with the same problem and options\n",
    "optimizer = mo.SLSQP(\n",
    "    problem, \n",
    "    solver_options={'maxiter': 100, 'ftol': 1e-6}\n",
    "    )\n",
    "\n",
    "# Check the first derivatives defined in the ProblemLite object\n",
    "optimizer.check_first_derivatives(x=x0, step=1e-6)\n",
    "\n",
    "# Solve the problem and get the results\n",
    "results = optimizer.solve()\n",
    "\n",
    "# Print the results\n",
    "optimizer.print_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the output of `check_first_derivatives()`, we can see that the derivatives we defined earlier are correct.\n",
    "We also printed the results using the optimizer's built-in `print_results()` method.\n",
    "However, note that the callbacks made by the optimizer in this case is more than in the previous case.\n",
    "These additional callbacks were made by the optimizer when checking the first derivatives using finite differences.\n",
    "\n",
    "## List of optimization algorithms\n",
    "\n",
    "We only looked at the `SLSQP` optimizer in the examples above.\n",
    "However, there are several more optimizers in the modOpt library.\n",
    "For more information on any specific optimizer, please visit its page linked below.\n",
    "\n",
    "```{toctree}\n",
    ":maxdepth: 2\n",
    "\n",
    "performant_algs\n",
    "educational_algs\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Live visualization of optimization\n",
    "Users have the option to visualize scalar variables during an optimization.\n",
    "There are two categories of variables that can be visualized.\n",
    "The first category includes the user-provided problem functions, derivatives, and their inputs,\n",
    "which are called the **callback_variables** because these functions are\n",
    "called repeatedly by the optimizer with its inputs.\n",
    "Variables in this category include the optimization variables, objective, constraints, objective gradient,\n",
    "and constraint jacobian, among others.\n",
    "The second category, called the **optimizer_variables**, includes variables that are\n",
    "made available by the optimizer after each optimization iteration.\n",
    "These variables are optimizer-dependent and vary widely from one optimizer to another.\n",
    "To see the list of variables made available by each optimizer, check the `available_outputs` attribute,\n",
    "as shown in the code snippet below.\n",
    "The full list of keywords for the **callback_variables** is\n",
    "`['x', 'mu', 'obj', 'con', 'grad', 'jac', 'obj_hess', 'lag_hess']`, \n",
    "where `x` represents the optimization variable vector, and `mu` represents the vector of Lagrange multipliers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': (<class 'float'>, (2,))}\n",
      "{'x': (<class 'float'>, (2,)), 'obj': <class 'float'>, 'opt': <class 'float'>, 'feas': <class 'float'>, 'grad': (<class 'float'>, (2,)), 'lgrad': (<class 'float'>, (2,)), 'con': (<class 'float'>, (2,)), 'jac': (<class 'float'>, (2, 2)), 'lmult_x': (<class 'float'>, (2,)), 'lmult_c': (<class 'float'>, (2,)), 'iter': <class 'int'>, 'cg_niter': <class 'int'>, 'nfev': <class 'int'>, 'nfgev': <class 'int'>, 'nfhev': <class 'int'>, 'ncev': <class 'int'>, 'ncgev': <class 'int'>, 'nchev': <class 'int'>, 'tr_radius': <class 'float'>, 'constr_penalty': <class 'float'>, 'barrier_parameter': <class 'float'>, 'barrier_tolerance': <class 'float'>, 'cg_stop_cond': <class 'float'>, 'time': <class 'float'>}\n"
     ]
    }
   ],
   "source": [
    "# Print available outputs for the SLSQP optimizer\n",
    "optimizer = mo.SLSQP(problem=problem)\n",
    "print(optimizer.available_outputs)\n",
    "\n",
    "# Print available outputs for the TrustConstr optimizer\n",
    "optimizer = mo.TrustConstr(problem=problem)\n",
    "print(optimizer.available_outputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To visualize scalar variables of interest, simply pass them as a list using the keyword argument `visualize` when instantiating an optimizer.\n",
    "The callback variable names will always be prefixed with `callback_` in the visualization. \n",
    "If a variable name is available in both **callback_variables** and **optimizer_variables**, both will be plotted.\n",
    "The code below demonstrates how to visualize the optimization variable $x_1$, the objective, and optimality \n",
    "when using the `TrustConstr` optimizer.\n",
    "Note that the `keep_viz_open` parameter must be set to `True` to keep\n",
    "the plot open once the optimization is complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/venv/lib/python3.9/site-packages/scipy/optimize/_differentiable_functions.py:504: UserWarning: delta_grad == 0.0. Check if the approximated function is linear. If the function is linear better results can be obtained by defining the Hessian as zero instead of using quasi-Newton approximations.\n",
      "  self.H.update(delta_x, delta_g)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1500 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\tSolution from Scipy trust-constr:\n",
      "\t----------------------------------------------------------------------------------------------------\n",
      "\tProblem                       : constrained_quadratic\n",
      "\tSolver                        : scipy-trust-constr\n",
      "\tMethod                        : tr_interior_point\n",
      "\tSuccess                       : True\n",
      "\tMessage                       : `gtol` termination condition is satisfied.\n",
      "\tStatus                        : 1\n",
      "\tTotal time                    : 9.935916662216187\n",
      "\tObjective                     : 1.0000320268995626\n",
      "\tGradient norm                 : 2.000032026643136\n",
      "\tOptimality                    : 4.3125588820511207e-13\n",
      "\tMax. constr. violation        : 0.0\n",
      "\tTrust region radius           : 639535.7360242795\n",
      "\tConstraint penalty            : 1.0\n",
      "\tBarrier parameter             : 3.200000000000001e-05\n",
      "\tBarrier tolerance             : 3.200000000000001e-05\n",
      "\tTotal function evals          : 13\n",
      "\tTotal gradient evals          : 13\n",
      "\tTotal Hessian evals           : 0\n",
      "\tTotal constraint evals        : 13\n",
      "\tTotal constr. Jacobian evals  : 13\n",
      "\tTotal constr. Hessian evals   : 0\n",
      "\tTotal iterations              : 18\n",
      "\tCG iterations                 : 12\n",
      "\tCG stop condition             : 1\n",
      "\tTotal callbacks               : 52\n",
      "\tReused callbacks              : 0\n",
      "\tobj callbacks                 : 13\n",
      "\tgrad callbacks                : 13\n",
      "\thess callbacks                : 0\n",
      "\tcon callbacks                 : 13\n",
      "\tjac callbacks                 : 13\n",
      "\t----------------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "optimizer = mo.TrustConstr(problem=problem, \n",
    "                           solver_options={'maxiter': 100, 'gtol': 1e-12},\n",
    "                           visualize=['x[0]', 'obj', 'opt'],\n",
    "                           keep_viz_open=True)\n",
    "results   = optimizer.solve()\n",
    "optimizer.print_results()\n",
    "\n",
    "# To visualize the results, when using the `optimize` function\n",
    "# mo.optimize(problem, solver='TrustConstr', visualize=['x[0]', 'obj', 'opt'], keep_viz_open=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that for $x_1$ and the objective, we see two plots each--one reported from the callbacks \n",
    "and the other reported from the optimizer iterations.\n",
    "The results printed at the end show the `total_callbacks` as 52 and `obj_callbacks` as 13\n",
    "which match the number of points on the corresponding plots.\n",
    "Similarly, we see 18 points plotted on the `x[0]`, `obj`, and `opt` plots, corresponding\n",
    "to the total number of optimization iterations reported in the results.\n",
    "\n",
    "## Recording\n",
    "When optimizing a problem, users may want to record the entire optimization history\n",
    "for several reasons, such as post-processing, hot-restarting an optimization that \n",
    "terminated prematurely, or for further analysis.\n",
    "Refer to [Post-processing](./postprocessing.md) for details on how to access and work with optimization records.\n",
    "\n",
    "Users can set `recording=True` to save the full history of the callbacks \n",
    "and optimizer iterations (see **callback_variables** and **optimizer_variables** discussed above).\n",
    "The following code shows how to record an optimization using the same\n",
    "example solved above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\tSolution from Scipy trust-constr:\n",
      "\t----------------------------------------------------------------------------------------------------\n",
      "\tProblem                       : constrained_quadratic\n",
      "\tSolver                        : scipy-trust-constr\n",
      "\tMethod                        : tr_interior_point\n",
      "\tSuccess                       : True\n",
      "\tMessage                       : `gtol` termination condition is satisfied.\n",
      "\tStatus                        : 1\n",
      "\tTotal time                    : 0.439133882522583\n",
      "\tObjective                     : 1.0000320268995626\n",
      "\tGradient norm                 : 2.000032026643136\n",
      "\tOptimality                    : 4.3125588820511207e-13\n",
      "\tMax. constr. violation        : 0.0\n",
      "\tTrust region radius           : 639535.7360242795\n",
      "\tConstraint penalty            : 1.0\n",
      "\tBarrier parameter             : 3.200000000000001e-05\n",
      "\tBarrier tolerance             : 3.200000000000001e-05\n",
      "\tTotal function evals          : 13\n",
      "\tTotal gradient evals          : 13\n",
      "\tTotal Hessian evals           : 0\n",
      "\tTotal constraint evals        : 13\n",
      "\tTotal constr. Jacobian evals  : 13\n",
      "\tTotal constr. Hessian evals   : 0\n",
      "\tTotal iterations              : 18\n",
      "\tCG iterations                 : 12\n",
      "\tCG stop condition             : 1\n",
      "\tTotal callbacks               : 52\n",
      "\tReused callbacks              : 0\n",
      "\tobj callbacks                 : 13\n",
      "\tgrad callbacks                : 13\n",
      "\thess callbacks                : 0\n",
      "\tcon callbacks                 : 13\n",
      "\tjac callbacks                 : 13\n",
      "\t----------------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "optimizer = mo.TrustConstr(problem=problem, \n",
    "                           solver_options={'maxiter': 100, 'gtol': 1e-12},\n",
    "                           recording=True)\n",
    "results   = optimizer.solve()\n",
    "optimizer.print_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Directory structure\n",
    "\n",
    "When instantiating an optimizer for the first time for a problem, modOpt creates a directory for that problem, \n",
    "named using the `problem_name` with the suffix `_outputs`.\n",
    "Each time a new optimizer object is instantiated for the same problem, \n",
    "modOpt creates a new directory within `{problem_name}_outputs\\` based on the timestamp at the time of instantiation.\n",
    "All outputs generated by modOpt for an optimization will be placed in this directory.\n",
    "\n",
    "The optimization recording is saved as an HDF5 file named `record.hdf5`.\n",
    "The relative path to the outputs directory is stored in the `out_dir` attribute of the optimizer, and all files \n",
    "available in the directory are stored in the `modopt_output_files` attribute.\n",
    "The code below prints these attributes for the optimization performed above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output Directory: constrained_quadratic_outputs/2025-02-03_10.51.04.574227\n",
      "Output Files: ['directory: constrained_quadratic_outputs/2025-02-03_10.51.04.574227', 'modopt_results.out', 'modopt_summary.out', 'record.hdf5']\n"
     ]
    }
   ],
   "source": [
    "# Print the directory containing all the output files generated by the optimizer\n",
    "print('Output Directory:', optimizer.out_dir)\n",
    "print('Output Files:', optimizer.modopt_output_files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting readable outputs from the optimizer\n",
    "\n",
    "Since HDF5 files from optimizer recording are incompatible with text editors, \n",
    "users may set the `readable_outputs` option during optimizer instantiation \n",
    "to export optimizer-generated data (**optimizer_variables**) as plain text files.\n",
    "For each variable listed in `readable_outputs`, a separate file is generated,\n",
    "with rows representing optimizer iterations.\n",
    "The list of variables allowed for `readable_outputs` is any\n",
    "subset of the keys in the `available_outputs` attribute.\n",
    "These dynamically updated plain text files allow users to track \n",
    "different optimization variables during the optimization.\n",
    "\n",
    "The following code demonstrates how to set the `readable_outputs` option\n",
    "for the `TrustConstr` optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\tSolution from Scipy trust-constr:\n",
      "\t----------------------------------------------------------------------------------------------------\n",
      "\tProblem                       : constrained_quadratic\n",
      "\tSolver                        : scipy-trust-constr\n",
      "\tMethod                        : tr_interior_point\n",
      "\tSuccess                       : True\n",
      "\tMessage                       : `gtol` termination condition is satisfied.\n",
      "\tStatus                        : 1\n",
      "\tTotal time                    : 0.07374691963195801\n",
      "\tObjective                     : 1.0000320268995626\n",
      "\tGradient norm                 : 2.000032026643136\n",
      "\tOptimality                    : 4.3125588820511207e-13\n",
      "\tMax. constr. violation        : 0.0\n",
      "\tTrust region radius           : 639535.7360242795\n",
      "\tConstraint penalty            : 1.0\n",
      "\tBarrier parameter             : 3.200000000000001e-05\n",
      "\tBarrier tolerance             : 3.200000000000001e-05\n",
      "\tTotal function evals          : 13\n",
      "\tTotal gradient evals          : 13\n",
      "\tTotal Hessian evals           : 0\n",
      "\tTotal constraint evals        : 13\n",
      "\tTotal constr. Jacobian evals  : 13\n",
      "\tTotal constr. Hessian evals   : 0\n",
      "\tTotal iterations              : 18\n",
      "\tCG iterations                 : 12\n",
      "\tCG stop condition             : 1\n",
      "\tTotal callbacks               : 52\n",
      "\tReused callbacks              : 0\n",
      "\tobj callbacks                 : 13\n",
      "\tgrad callbacks                : 13\n",
      "\thess callbacks                : 0\n",
      "\tcon callbacks                 : 13\n",
      "\tjac callbacks                 : 13\n",
      "\t----------------------------------------------------------------------------------------------------\n",
      "Output Directory: constrained_quadratic_outputs/2025-02-03_11.16.39.260346\n",
      "Output Files: ['directory: constrained_quadratic_outputs/2025-02-03_11.16.39.260346', 'modopt_results.out', 'modopt_summary.out', 'obj.out', 'con.out', 'x.out', 'opt.out', 'feas.out']\n"
     ]
    }
   ],
   "source": [
    "optimizer = mo.TrustConstr(problem=problem, \n",
    "                           solver_options={'maxiter': 100, 'gtol': 1e-12},\n",
    "                           readable_outputs=['obj', 'con', 'x', 'opt', 'feas'])\n",
    "results   = optimizer.solve()\n",
    "optimizer.print_results()\n",
    "\n",
    "# Print the directory and its contents to see the generated readable output files\n",
    "print('Output Directory:', optimizer.out_dir)\n",
    "print('Output Files:', optimizer.modopt_output_files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the output files listed in the console output above, we see that \n",
    "five additional plain text files \n",
    "(*'obj.out'*, *'con.out'*, *'x.out'*, *'opt.out'*, *'feas.out'*)\n",
    "were generated by modOpt based on the `readable_outputs` argument \n",
    "provided to the optimizer.\n",
    "\n",
    "## Disabling modOpt-generated outputs\n",
    "By default, modOpt generates the `modopt_results.out` file along with other files,\n",
    "depending on the optimizer.\n",
    "To disable the generation of all output files, set `turn_off_outputs=True`\n",
    "when instantiating an optimizer, as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = mo.TrustConstr(problem=problem, \n",
    "                           turn_off_outputs=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more details on the `Optimizer` class or any of the features discussed above, \n",
    "visit the [API Reference](./api.md) page."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}