{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Post-processing\n",
    "In this section, we discuss how to access and work with data from optimization records.\n",
    "This includes loading various data, visualizing results, and hot-starting an optimization \n",
    "using optimization records.\n",
    "\n",
    "## Recording an optimization\n",
    "We start by recording an optimization, as discussed in the [previous section](./optimization.ipynb).\n",
    "The problem is the same as before, and we use the `TrustConstr` optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.14261221885681152\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_12.25.55.893290\n",
      "Output Files: ['directory: constrained_quadratic_outputs/2025-02-03_12.25.55.893290', 'modopt_results.out', 'modopt_summary.out', 'record.hdf5']\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",
    "    )\n",
    "\n",
    "optimizer = mo.TrustConstr(problem=problem, \n",
    "                           solver_options={'maxiter': 100, 'gtol': 1e-12},\n",
    "                           recording=True)\n",
    "results   = optimizer.solve()\n",
    "optimizer.print_results()\n",
    "\n",
    "# Print the directory and its contents to see the generated output files\n",
    "print('Output Directory:', optimizer.out_dir)\n",
    "print('Output Files:', optimizer.modopt_output_files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Viewing record contents\n",
    "\n",
    "To view the data available in a record, call the `print_record_contents()` utility with the record file name,\n",
    "as shown below.\n",
    "There are four types of information available in a record: `attributes`, `opt_vars`, `callback_vars`, and `results`.\n",
    "The `print_record_contents()` function always returns a tuple containing four lists, one for each type of information.\n",
    "To suppress printing, set the keyword argument `suppress_print=True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available data in the record:\n",
      "-----------------------------\n",
      " - Attributes of optimization    : ['c_lower', 'c_scaler', 'c_upper', 'constrained', 'hot_start_from', 'modopt_output_files', 'nc', 'nx', 'o_scaler', 'problem_name', 'readable_outputs', 'recording', 'solver_name', 'solver_options-barrier_tol', 'solver_options-callback', 'solver_options-factorization_method', 'solver_options-gtol', 'solver_options-ignore_exact_hessian', 'solver_options-initial_barrier_parameter', 'solver_options-initial_barrier_tolerance', 'solver_options-initial_constr_penalty', 'solver_options-initial_tr_radius', 'solver_options-maxiter', 'solver_options-sparse_jacobian', 'solver_options-verbose', 'solver_options-xtol', 'timestamp', 'visualize', 'x0', 'x_lower', 'x_scaler', 'x_upper']\n",
      " - Recorded optimizer variables  : ['barrier_parameter', 'barrier_tolerance', 'cg_niter', 'cg_stop_cond', 'con', 'constr_penalty', 'feas', 'grad', 'iter', 'jac', 'lgrad', 'lmult_c', 'lmult_x', 'ncev', 'ncgev', 'nchev', 'nfev', 'nfgev', 'nfhev', 'obj', 'opt', 'time', 'tr_radius', 'x']\n",
      " - Recorded callback variables   : ['con', 'grad', 'jac', 'obj', 'x']\n",
      " - Results of optimization       : ['barrier_parameter', 'barrier_tolerance', 'cg_niter', 'cg_stop_cond', 'con', 'con_evals', 'constr_penalty', 'feas', 'grad', 'grad_evals', 'hess_evals', 'iter', 'jac', 'jac_evals', 'lgrad', 'lmult_c', 'lmult_x', 'message', 'method', 'ncev', 'ncgev', 'nchev', 'nfev', 'nfgev', 'nfhev', 'obj', 'obj_evals', 'opt', 'out_dir', 'reused_callbacks', 'status', 'success', 'time', 'total_callbacks', 'tr_radius', 'x']\n"
     ]
    }
   ],
   "source": [
    "from modopt.postprocessing import print_record_contents\n",
    "record_contents = print_record_contents(optimizer.out_dir+'/record.hdf5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading results and attributes\n",
    "\n",
    "Attributes and results of an optimization can be loaded as dictionaries \n",
    "by calling the `load_attributes()` and `load_results()` utility functions \n",
    "with the record file name, as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attributes:\n",
      "{'c_lower': array([1., 1.]), 'c_scaler': array([ 10., 100.]), 'c_upper': array([ 1., inf]), 'constrained': True, 'hot_start_from': 'None', 'modopt_output_files': ['directory: constrained_quadratic_outputs/2025-02-03_12.25.55.893290', 'modopt_results.out', 'modopt_summary.out', 'record.hdf5'], 'nc': 2, 'nx': 2, 'o_scaler': array([1.]), 'problem_name': 'constrained_quadratic', 'readable_outputs': [], 'recording': 'True', 'solver_name': 'scipy-trust-constr', 'solver_options-barrier_tol': 1e-08, 'solver_options-callback': 'None', 'solver_options-factorization_method': 'None', 'solver_options-gtol': 1e-12, 'solver_options-ignore_exact_hessian': False, 'solver_options-initial_barrier_parameter': 0.1, 'solver_options-initial_barrier_tolerance': 0.1, 'solver_options-initial_constr_penalty': 1.0, 'solver_options-initial_tr_radius': 1.0, 'solver_options-maxiter': 100, 'solver_options-sparse_jacobian': 'None', 'solver_options-verbose': 0, 'solver_options-xtol': 1e-08, 'timestamp': '2025-02-03_12.25.55.893290', 'visualize': [], 'x0': array([50.,  5.]), 'x_lower': array([  0., -inf]), 'x_scaler': array([1., 1.]), 'x_upper': array([inf, inf])}\n",
      "Results:\n",
      "{'barrier_parameter': 3.200000000000001e-05, 'barrier_tolerance': 3.200000000000001e-05, 'cg_niter': 12, 'cg_stop_cond': 1, 'con': array([ 10.        , 100.00320264]), 'con_evals': 13, 'constr_penalty': 1.0, 'feas': 0.0, 'grad': array([ 2.00003203e+00, -3.20263867e-05]), 'grad_evals': 13, 'hess_evals': 0, 'iter': 18, 'jac': array([[  10.,   10.],\n",
      "       [ 100., -100.]]), 'jac_evals': 13, 'lgrad': array([ 4.31139106e-13, -4.31255888e-13]), 'lmult_c': array([-0.0999984 , -0.01000016]), 'lmult_x': array([-3.1999488e-05,  0.0000000e+00]), 'message': '`gtol` termination condition is satisfied.', 'method': b'tr_interior_point', 'ncev': 13, 'ncgev': 13, 'nchev': 0, 'nfev': 13, 'nfgev': 13, 'nfhev': 0, 'obj': 1.0000320268995626, 'obj_evals': 13, 'opt': 4.3125588820511207e-13, 'out_dir': 'constrained_quadratic_outputs/2025-02-03_12.25.55.893290', 'reused_callbacks': 0, 'status': 1, 'success': True, 'time': 0.13321709632873535, 'total_callbacks': 52, 'tr_radius': 639535.7360242795, 'x': array([ 1.00001601e+00, -1.60131934e-05])}\n"
     ]
    }
   ],
   "source": [
    "from modopt.postprocessing import load_attributes, load_results\n",
    "attributes = load_attributes(optimizer.out_dir+'/record.hdf5')\n",
    "results    = load_results(optimizer.out_dir+'/record.hdf5')\n",
    "\n",
    "print(\"Attributes:\")\n",
    "print(attributes)\n",
    "\n",
    "print(\"Results:\")\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading variable iterates\n",
    "\n",
    "The `load_variables()` utility function loads variable iterates from the record.\n",
    "This function requires two arguments: 1) the record file name, and 2) the list of variable names to load. \n",
    "The function returns a dictionary with *keys* as variable names and *values* as lists of variable iterates \n",
    "corresponding to those variable names.\n",
    "Note that the keys for **callback_variables** will be prefixed with `'callback_'`.\n",
    "If only specific scalar variables need to be loaded from an array variable, use the format `'var_name[idx]'`.\n",
    "For example,\n",
    "- `'x[0]'` will load the iterates for the first element of the array 'x', and\n",
    "- `'jac[i,j]'` will load the iterates for the (i,j)-th element of the array 'jac'.\n",
    "\n",
    "The `load_variables()` function also provides an optional keyword argument, `callback_context`,\n",
    "to load **callback_variables** together with its corresponding inputs. \n",
    "To learn more about `callback_context`, visit the [API Reference](./api/postprocessing.md).\n",
    "\n",
    "The following code loads the iterates of x[0], the objective, the Jacobian, optimality, and feasibility\n",
    "from the record."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded variables:\n",
      "dict_keys(['x[0]', 'callback_x[0]', 'obj', 'callback_obj', 'jac', 'callback_jac', 'opt', 'feas'])\n",
      "\n",
      " x[0] :\n",
      "[50.0, 49.06680741392834, 42.1402716614226, 13.137131926669479, 3.265462548872426, 1.426337395295874, 1.1484153222707345, 1.0661629237127606, 1.0661629237127606, 1.0170864850904997, 1.0170864850904997, 1.0026442417982402, 1.0026442417982402, 1.0004156095347128, 1.0004156095347128, 1.0000803575038417, 1.0000803575038417, 1.0000160131933589]\n",
      "\n",
      " callback_x[0] :\n",
      "[50.0, 50.0, 50.0, 50.0, 49.06680741392834, 49.06680741392834, 49.06680741392834, 49.06680741392834, 42.1402716614226, 42.1402716614226, 42.1402716614226, 42.1402716614226, 13.137131926669479, 13.137131926669479, 13.137131926669479, 13.137131926669479, 3.265462548872426, 3.265462548872426, 3.265462548872426, 3.265462548872426, 1.426337395295874, 1.426337395295874, 1.426337395295874, 1.426337395295874, 1.1484153222707345, 1.1484153222707345, 1.1484153222707345, 1.1484153222707345, 1.0661629237127606, 1.0661629237127606, 1.0661629237127606, 1.0661629237127606, 1.0170864850904997, 1.0170864850904997, 1.0170864850904997, 1.0170864850904997, 1.0026442417982402, 1.0026442417982402, 1.0026442417982402, 1.0026442417982402, 1.0004156095347128, 1.0004156095347128, 1.0004156095347128, 1.0004156095347128, 1.0000803575038417, 1.0000803575038417, 1.0000803575038417, 1.0000803575038417, 1.0000160131933589, 1.0000160131933589, 1.0000160131933589, 1.0000160131933589]\n",
      "\n",
      " obj :\n",
      "[2525.0, 2431.6089501192855, 1791.1150473325854, 172.71635837369885, 11.873365835978536, 2.216201939847089, 1.3408848603109211, 1.1410809123739623, 1.1410809123739623, 1.0347568661264952, 1.0347568661264952, 1.0053024676258553, 1.0053024676258553, 1.000831564531996, 1.000831564531996, 1.0001607279223403, 1.0001607279223403, 1.0000320268995626]\n",
      "\n",
      " callback_obj :\n",
      "[2525.0, 2431.6089501192855, 1791.1150473325854, 172.71635837369885, 11.873365835978536, 2.216201939847089, 1.3408848603109211, 1.1410809123739623, 1.0347568661264952, 1.0053024676258553, 1.000831564531996, 1.0001607279223403, 1.0000320268995626]\n",
      "\n",
      " jac :\n",
      "[array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]])]\n",
      "\n",
      " callback_jac :\n",
      "[array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]]), array([[  10.,   10.],\n",
      "       [ 100., -100.]])]\n",
      "\n",
      " opt :\n",
      "[44.97317172737661, 44.10755536872242, 38.16378116721319, 12.56369482254608, 3.616883389849403, 0.4254477324883117, 0.03805897490957255, 0.002850769190926694, 0.008402289887398908, 0.0002561569722679402, 0.000533892876432962, 3.453049888618026e-06, 1.1936761440439064e-05, 1.3123963654433461e-08, 2.7922443006974523e-07, 5.84988753130674e-11, 1.0345085697445759e-08, 4.3125588820511207e-13]\n",
      "\n",
      " feas :\n",
      "[540.0, 529.716377192246, 450.53397219603494, 125.0061936108822, 11.654079239150402, 1.7763568394002505e-15, 1.7763568394002505e-15, 1.7763568394002505e-15, 1.7763568394002505e-15, 1.7763568394002505e-15, 1.7763568394002505e-15, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]\n"
     ]
    }
   ],
   "source": [
    "from modopt.postprocessing import load_variables\n",
    "vars = load_variables(optimizer.out_dir+'/record.hdf5', ['x[0]', 'obj', 'jac', 'opt', 'feas'])\n",
    "\n",
    "print('Loaded variables:')\n",
    "print(vars.keys())\n",
    "\n",
    "# Print the loaded variable iterates\n",
    "for key, value in vars.items():\n",
    "    print('\\n', key, ':')\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing recorded optimization\n",
    "A recorded optimization can be visualized using the `visualize()` function from the post-processing utilities.\n",
    "This function plots scalar variables after loading them from the record.\n",
    "The two required arguments are: 1) the record file name, and 2) the list of variable names to visualize. \n",
    "The final optimization plot can be saved to a file by setting the keyword argument `save_figname`,\n",
    "which is `None` by default.\n",
    "\n",
    "The following code plots the iterations of x[0], the objective, the Jacobian, optimality, and feasibility\n",
    "from the record and saves them to a file named *'post_opt_viz.pdf'*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1500 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "from modopt.postprocessing import visualize\n",
    "visualize(optimizer.out_dir+'/record.hdf5', ['x[0]', 'obj', 'opt', 'feas', 'jac[0,0]'], save_figname='post_opt_viz.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Restarting optimization: Hot-starts leveraging previous records\n",
    "\n",
    "In practical situations, users may need to rerun a previously completed optimization \n",
    "if it terminates before reaching a sufficiently optimal solution.\n",
    "For instance, this may occur when an algorithm exits due to reaching the iteration limit or\n",
    "loosely set convergence tolerances.\n",
    "In such cases, the optimization must be re-executed with a higher iteration limit\n",
    "or tighter tolerances to achieve the desired results.\n",
    "When the problem functions and/or their derivatives are costly to evaluate,\n",
    "even a few reruns can significantly increase the overall optimization time, \n",
    "making it highly inefficient.\n",
    "The hot-starting feature in modOpt utilizes the record file from a prior optimization \n",
    "to efficiently reuse previously computed function and derivative values, thereby\n",
    "avoiding unnecessary computational costs.\n",
    "\n",
    "One key benefit of hot-starting, as opposed to simply restarting from the previous solution, is\n",
    "that quasi-Newton methods maintain the same Hessian approximations from the prior run during\n",
    "a hot-start.\n",
    "In contrast, normal restarting initializes the approximate Hessian as an identity matrix, \n",
    "potentially increasing the number of additional iterations required for convergence, \n",
    "even if we start from the previous solution.\n",
    "Furthermore, restarting resets the Lagrange multipliers, which may also necessitate additional iterations, \n",
    "as the convergence of optimization variables often follows the convergence of Lagrange multipliers.\n",
    "\n",
    "To hot-start a problem, set the `hot_start_from` parameter when instantiating the optimizer object. \n",
    "The `hot_start_from` parameter specifies the record from which \n",
    "the data should be reused when rerunning an optimization.\n",
    "Users can also set `hot_start_atol` and `hot_start_rtol`, \n",
    "which define the absolute and relative tolerances for the inputs \n",
    "when reusing outputs from the hot-start record.\n",
    "These tolerances are particularly useful in distributed computing environments \n",
    "where computations are performed across multiple processors or GPUs, \n",
    "as numerical discrepancies may arise due to variations in floating-point arithmetic and parallel execution.\n",
    "Both tolerances are set to zero by default.\n",
    "<!-- These tolerances are particularly useful in situations \n",
    "where computations are distributed over multiple processors or GPUs,\n",
    "leading to outputs that are not always exact up to machine precision. -->\n",
    "\n",
    "The following code hot-starts the same problem we solved and recorded at the beginning of this page\n",
    "but with a tighter tolerance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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.21609711647033691\n",
      "\tObjective                     : 1.0000064010669836\n",
      "\tGradient norm                 : 2.00000640105674\n",
      "\tOptimality                    : 3.5429931286978106e-15\n",
      "\tMax. constr. violation        : 1.7763568394002505e-15\n",
      "\tTrust region radius           : 3197678.6801213976\n",
      "\tConstraint penalty            : 1.0\n",
      "\tBarrier parameter             : 6.400000000000003e-06\n",
      "\tBarrier tolerance             : 6.400000000000003e-06\n",
      "\tTotal function evals          : 14\n",
      "\tTotal gradient evals          : 14\n",
      "\tTotal Hessian evals           : 0\n",
      "\tTotal constraint evals        : 14\n",
      "\tTotal constr. Jacobian evals  : 14\n",
      "\tTotal constr. Hessian evals   : 0\n",
      "\tTotal iterations              : 20\n",
      "\tCG iterations                 : 13\n",
      "\tCG stop condition             : 1\n",
      "\tTotal callbacks               : 56\n",
      "\tReused callbacks              : 52\n",
      "\tobj callbacks                 : 14\n",
      "\tgrad callbacks                : 14\n",
      "\thess callbacks                : 0\n",
      "\tcon callbacks                 : 14\n",
      "\tjac callbacks                 : 14\n",
      "\t----------------------------------------------------------------------------------------------------\n"
     ]
    },
    {
     "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"
     ]
    }
   ],
   "source": [
    "hot_start_record = optimizer.out_dir+'/record.hdf5'\n",
    "optimizer = mo.TrustConstr(problem=problem, \n",
    "                           solver_options={'maxiter': 100, 'gtol': 1e-14},\n",
    "                           hot_start_from= hot_start_record)\n",
    "results   = optimizer.solve()\n",
    "optimizer.print_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the console output above, we see that out of the 56 callbacks made by the optimizer, \n",
    "52 were reused from the previous record and were never recomputed using the user-provided functions.\n",
    "Only one new evaluation of the objective, gradient, constraint, and Jacobian was performed \n",
    "to achieve a more optimal solution necessitated by the tighter tolerance.\n",
    "\n",
    "For more details on any of the post-processing utilities, \n",
    "visit the [API Reference](./api/postprocessing.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
}