diff --git a/docs/Examples/BlockSlide_1.ipynb b/docs/Examples/BlockSlide_1.ipynb new file mode 100644 index 0000000..48edbb8 --- /dev/null +++ b/docs/Examples/BlockSlide_1.ipynb @@ -0,0 +1,614 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "b8ac7332", + "metadata": {}, + "source": [ + "# Single Phase" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "4f1f4a98", + "metadata": {}, + "source": [ + "## OCP Description\n", + "To first show simple implementation of an OptimalControlProblem(OCP) in pycollo we will solve a block slide. A block will be pushed in 1D by a force ($F_x$) and should reach a certain position ending with 0 speed with friction. The objective function is to minimize pushing force. To describe this problem we need two state variables (position $x$ and speed $dx$), one control variable (Applied force $F_x$), and three static parameters variables to describe friction (gravitation $g$, mass $m$, and coefficient of friction $\\mu$). We will introduce a second order differential by means of the state equations to be able to solve the differential equations for the equations of motion." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "48d93492", + "metadata": {}, + "outputs": [], + "source": [ + "# 1D Blockslide\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import sympy as sym\n", + "import pycollo\n", + "\n", + "# State variables\n", + "x = sym.Symbol(\"x\") # Position (m) of the block horizontally from the origin (x-axis)\n", + "dx = sym.Symbol(\"dx\") # Velocity (m/s) of the block horizontally (x-axis)\n", + "# Control variables\n", + "Fx = sym.Symbol(\"Fx\") # Force (N) applied to the block horizontally (x-axis)\n", + "\n", + "# Static parameter variable\n", + "g = sym.Symbol(\"g\") # Gravitational acceleration (m/s^2)\n", + "m = sym.Symbol(\"m\") # Mass (kg) of the block\n", + "mu = sym.Symbol(\"mu\") # Coefficient of friction (-)\n", + "\n", + "# State equation variables\n", + "ddx = sym.Symbol(\"ddx\") # Acceleration (m/s^2) of the block horizontal (x-axis)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "ae5dfdb7", + "metadata": {}, + "source": [ + "## Parameters variables\n", + "To initialise an OCP in pycollo start by creating the name and introducing optimised parameters. These are provided in a list or tuple. When these variables are optimised, they will be optimised to a single constant number over all phases. It is good to note that ALWAYS when you want anything to be optimised, make sure bounds and guesses are supplied, otherwise Pycollo cannot run. Bounds can be assigned with list of list, tuples, array, or dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "36cc74de", + "metadata": {}, + "outputs": [], + "source": [ + "# Problem instantiation\n", + "problem = pycollo.OptimalControlProblem(\n", + " name=\"Simple Block Slide\",\n", + " parameter_variables= (m,mu)\n", + " )\n", + "problem.bounds.parameter_variables = [[1,2], [0.5,1]]\n", + "problem.guess.parameter_variables = [1.5, 0.75]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "65cc77dc", + "metadata": {}, + "source": [ + "## Problem specific auxiliary data\n", + "Non optimised static parameters should be assigned a numerical value. This is done through auxiliary data. Auxiliary data is a dictionary where symbols can be assigned to numerical values, or sympy expressions(see [Phase specific auxiliary data](#Phase-specific-auxiliary-data)). If you want to exclude the variables from all equations in the OCP, you can make sure the variables are numerical before introducing them into the OCP_instance." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "30bc9854", + "metadata": {}, + "outputs": [], + "source": [ + "problem.auxiliary_data = {g: 9.81}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "5c313be8", + "metadata": {}, + "source": [ + "## Phases\n", + "The OCP is introduced, now we should start by introducing the phases. Eventhough we are only using a single phase for this OCP, the nature of Pycollo is multiphase, so phases should always be declared." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e2c75a26", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A = problem.new_phase(name=\"A\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "1678edce", + "metadata": {}, + "source": [ + "## Time\n", + "Each phase typically has a certain timespan. We wan't the time to start at 0 and will constrain the OCP to do so. By setting a single numerical number the initial time will be 0. Pycollo allows the initial and final time variables to be optimised. When a bound is provided time will be optimised. In this example, we don't know what the final time will be and thus will be optimised by a provided bound. A guess should be provided for time. Time guess should minimally be for the initial time and final time, but can expand to as many points as needed by providing a list of n numbers. Make sure to match length n with all other guesses (except for parameter variables and integral variables since they will always converge to a single number)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1ac5247a", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.bounds.initial_time = 0\n", + "phase_A.bounds.final_time = [0, 5]\n", + "phase_A.guess.time = [0, 1]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c4545a73", + "metadata": {}, + "source": [ + "## State variables, initialisation and bounds\n", + "The phase should know what the state variables and control variables are. Variables should be sympy symbols. Bounds and guessesv have to be numerical and cannot include symbolic variables. Bounds are defined as the allowable operating range of the given variables. Bounds can be provided to Pycollo as a list, list of list, tuple of list, numpy array, or dictionary. When the bounds are supplied with a list, tuple or numpy array, Pycollo will couple the values with by index. Bounds are set such that the objective is feasible and a reasonable amount of play such that the optimisation will not operate at it's bound (unless there is an actual bound in the problem)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6d278e6d", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.state_variables = [x, dx]\n", + "phase_A.bounds.state_variables = [[-3,3],[-50,50]]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0d62ab3a", + "metadata": {}, + "source": [ + "The dictionary is implemented by coupling a lower and upper bound through a list to the variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "876295ab", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.bounds.state_variables = {\n", + " x: [-3, 3],\n", + " dx: [-50, 50],}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "cb9b1a77", + "metadata": {}, + "source": [ + "Now the optimiser should know where the numerical initial and final state variables of this phase. Once again, when this should be optimised, you can assign a bound to these values, just like the parameter variables. Initial and final state constraints can also be assigned by a list, array or tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8acb7b1f", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.bounds.initial_state_constraints = {\n", + " x: 0,\n", + " dx: 0,}\n", + "phase_A.bounds.final_state_constraints = {\n", + " x: 1,\n", + " dx: 0,}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "9a61e3ab", + "metadata": {}, + "source": [ + "## Guess\n", + "The state variables are optimised, and thus need a guess. The guess of the state variables should, just like time, minimally include initial and final time. When n number of points is used for the time guess, state_variables guess should have n number of guesses per variable wich match the time by index. Minimal guessing would include initial and final time variables. Guesses are assigned with a list of lists, tuple, or array. Usually a zero guess seed is sufficient in this method. To converge quicker or make sure no local minima is found, proper guessing is needed. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cf1c9e53", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.guess.state_variables = [[0, 0], [0, 0]]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "977be00c", + "metadata": {}, + "source": [ + "## Control variables\n", + "The control variables are handeled the same as state variables, but don't need initial and final time constraints:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e05fa48b", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.control_variables = [Fx]\n", + "phase_A.bounds.control_variables = {\n", + " Fx: [-50, 50],}\n", + "phase_A.guess.control_variables = [\n", + " [0, 0],]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "1eb1a0b7", + "metadata": {}, + "source": [ + "## State equations\n", + "The integration over time can only be done when the differential equations of the blockslide are provided to Pycollo. The differential equations can be provided to Pycollo in three ways. First you can provide the equations directly:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "519ea7d1", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.state_equations = {\n", + " x: dx,\n", + " dx: Fx / m - m*mu,\n", + "}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f4305ec2", + "metadata": {}, + "source": [ + "## Phase specific auxiliary data\n", + "Secondly, you can provide it through auxiliary data, which results in fundamentally the same solution. Here you can see that auxiliary data can be used to assign expressions to variables. There are two kinds of auxiliary data: 1. Auxiliary data valid for all phases (`problem.auxiliary_data`) or specific per phase (`phase_A.auxiliary_data`). This can be helpful because constants can be different per phase." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1c33a6f7", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.state_equations = {\n", + " x: dx,\n", + " dx: ddx,\n", + "}\n", + "phase_A.auxiliary_data = {\n", + " ddx: Fx / m - m*mu, \n", + "}\n", + "phase_A.guess.control_variables = [\n", + " [0, 0],\n", + " ]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d21bd2f9", + "metadata": {}, + "source": [ + "## Path constraints\n", + "Thirdly, you can provide state equations with path constraints (also known as, inequality constraints). This is fundamentally different from the previous methods since the equations will be handled in the constraint space. Usually this will result in quicker, less acurate results (depending on NLP tolerance), but is sometimes necesary for example in bang bang control. We will not use this for now because this is not necessary. Later expansion of this example will elaborate on path constraints" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5164a6fb", + "metadata": {}, + "outputs": [], + "source": [ + "# phase_A.path_constraints = [ddx - (Fx / m - m*mu)]\n", + "# phase_A.bounds.path_constraints = [0]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "060c4a02", + "metadata": {}, + "source": [ + "## Integrand functions\n", + "The only step left is to implement an objective function. The objective is to slide the block to the endpoint while minimizing input $F_x$. To make sure we minimize $F_x$ over the whole time domain we should integrate $F_x$. To include negative effort in the equation we can square $F_x$. The bounds should be given for initial and final time, and the guess is a single number, since the output of the function will always result in a single number. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8874e0ff", + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.integrand_functions = [Fx ** 2]\n", + "phase_A.bounds.integral_variables = [[0, 1000]]\n", + "phase_A.guess.integral_variables = [0]\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "9af9fdcb", + "metadata": {}, + "source": [ + "## Objective function\n", + "Objective functions should always be a function of Endpoint variables. Endpoint variables are:\n", + "- Initial and final time state variables\n", + "- Ititial and final time\n", + "- Static parameter variables\n", + "- Integral variables\n", + "In this case we'd like to minimize the input over the whole phase, so we should get the integral of the input over the phase:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "60af8ae8", + "metadata": {}, + "outputs": [], + "source": [ + "problem.objective_function = (\n", + " phase_A.integral_variables[0])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c470d28c", + "metadata": {}, + "source": [ + "## Settings\n", + "Before solving the OCP we can alter Pycollo's default settings such as number of collocation points, amount of mesh sections, NLP tolerance. Click on settings to see all options. For now we will use Pycollo's default settings and will use it's internal plotting method to show the results. Then we will solve the OCP with:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9851c13a", + "metadata": {}, + "outputs": [], + "source": [ + "problem.settings.display_mesh_result_graph = True" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f1796197", + "metadata": {}, + "source": [ + "## Initialise and solve" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "0cfc0aa1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=====================================\n", + "Initialising optimal control problem.\n", + "=====================================\n", + "\n", + "Phase variables and equations checked.\n", + "Pycollo variables and constraints preprocessed.\n", + "Backend initialised.\n", + "Bounds checked.\n", + "Problem scaling initialised.\n", + "Quadrature scheme initialised.\n", + "Backend postprocessing complete.\n", + "Initial mesh created.\n", + "Initial guess checked.\n", + "\n", + "===============================\n", + "Initialising mesh iteration #1.\n", + "===============================\n", + "\n", + "Guess interpolated to iteration mesh in 1.65ms.\n", + "Scaling initialised in 120.83us.\n", + "Initial guess scaled in 21.12us.\n", + "Scaling generated in 2.18ms.\n", + "NLP generated in 71.56ms.\n", + "Mesh-specific bounds generated in 211.92us.\n", + "\n", + "Mesh iteration #1 initialised in 75.74ms.\n", + "\n", + "\n", + "==========================\n", + "Solving mesh iteration #1.\n", + "==========================\n", + "\n", + "\n", + "******************************************************************************\n", + "This program contains Ipopt, a library for large-scale nonlinear optimization.\n", + " Ipopt is released as open source code under the Eclipse Public License (EPL).\n", + " For more information visit https://github.com/coin-or/Ipopt\n", + "******************************************************************************\n", + "\n", + "This is Ipopt version 3.14.11, running with linear solver MUMPS 5.2.1.\n", + "\n", + "Number of nonzeros in equality constraint Jacobian...: 499\n", + "Number of nonzeros in inequality constraint Jacobian.: 0\n", + "Number of nonzeros in Lagrangian Hessian.............: 126\n", + "\n", + "Total number of variables............................: 93\n", + " variables with only lower bounds: 0\n", + " variables with lower and upper bounds: 93\n", + " variables with only upper bounds: 0\n", + "Total number of equality constraints.................: 61\n", + "Total number of inequality constraints...............: 0\n", + " inequality constraints with only lower bounds: 0\n", + " inequality constraints with lower and upper bounds: 0\n", + " inequality constraints with only upper bounds: 0\n", + "\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 0 9.9999900e+00 1.67e-01 0.00e+00 0.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", + " 1 9.9990000e-02 1.65e-02 4.38e+01 -6.3 1.66e-01 - 7.43e-01 9.90e-01f 1\n", + " 2 4.0937523e+00 1.47e-02 4.00e+01 -1.4 4.63e+00 0.0 1.05e-01 1.01e-01h 1\n", + " 3 2.2473369e+01 5.10e-03 7.36e+00 -1.2 1.02e-01 - 1.00e+00 1.00e+00h 1\n", + " 4 2.2472379e-01 4.51e-03 2.54e+00 -1.6 1.37e-01 - 9.84e-01 8.75e-01f 1\n", + " 5 3.5765401e-01 3.89e-03 1.51e+01 -1.7 6.79e-01 - 1.00e+00 1.40e-01h 1\n", + " 6 1.6777998e+00 2.30e-03 3.22e+00 -1.9 4.34e-01 - 1.00e+00 7.28e-01h 1\n", + " 7 1.1078523e+00 2.66e-03 3.76e-01 -2.3 1.33e-01 - 9.99e-01 1.00e+00h 1\n", + " 8 1.1321827e+00 1.34e-03 2.60e+00 -3.3 1.43e-01 - 1.00e+00 7.91e-01h 1\n", + " 9 1.1411053e+00 3.79e-04 3.06e-02 -4.0 9.21e-02 - 1.00e+00 1.00e+00h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 10 1.1542439e+00 1.54e-05 1.08e-03 -5.5 2.04e-02 - 1.00e+00 9.88e-01h 1\n", + " 11 1.1547004e+00 1.56e-08 1.06e-06 -7.6 8.02e-04 - 1.00e+00 1.00e+00h 1\n", + " 12 1.1547005e+00 3.59e-14 3.89e-12 -11.0 1.07e-06 - 1.00e+00 1.00e+00h 1\n", + "\n", + "Number of Iterations....: 12\n", + "\n", + " (scaled) (unscaled)\n", + "Objective...............: 1.1547004808427914e-01 1.1547004808427914e+00\n", + "Dual infeasibility......: 3.8947988362866978e-12 3.8947988362866978e-11\n", + "Constraint violation....: 3.5938844492970169e-14 3.5938844492970169e-14\n", + "Variable bound violation: 9.9752962556820535e-09 9.9752962556820535e-09\n", + "Complementarity.........: 1.0311194939135614e-11 1.0311194939135613e-10\n", + "Overall NLP error.......: 1.0311194939135614e-11 1.0311194939135613e-10\n", + "\n", + "\n", + "Number of objective function evaluations = 13\n", + "Number of objective gradient evaluations = 13\n", + "Number of equality constraint evaluations = 13\n", + "Number of inequality constraint evaluations = 0\n", + "Number of equality constraint Jacobian evaluations = 13\n", + "Number of inequality constraint Jacobian evaluations = 0\n", + "Number of Lagrangian Hessian evaluations = 12\n", + "Total seconds in IPOPT = 0.035\n", + "\n", + "EXIT: Optimal Solution Found.\n", + " solver : t_proc (avg) t_wall (avg) n_eval\n", + " nlp_f | 17.00us ( 1.31us) 18.08us ( 1.39us) 13\n", + " nlp_g | 156.00us ( 12.00us) 105.21us ( 8.09us) 13\n", + " nlp_grad_f | 50.00us ( 3.33us) 37.29us ( 2.49us) 15\n", + " nlp_hess_l | 128.00us ( 10.67us) 116.25us ( 9.69us) 12\n", + " nlp_jac_g | 189.00us ( 13.50us) 176.12us ( 12.58us) 14\n", + " total | 30.62ms ( 30.62ms) 46.53ms ( 46.53ms) 1\n", + "\n", + "==================================\n", + "Post-processing mesh iteration #1.\n", + "==================================\n", + "\n", + "Mesh iteration #1 solved in 47.10ms.\n", + "Mesh iteration #1 post-processed in 25.05ms.\n", + "\n", + "\n", + "============================\n", + "Analysing mesh iteration #1.\n", + "============================\n", + "\n", + "Objective Evaluation: 1.1547004808427914\n", + "Max Relative Mesh Error: 2.0754418645873966e-13\n", + "Collocation Points Used: 31\n", + "\n", + "Adjusting Collocation Mesh: [10] mesh sections\n", + "\n", + "Mesh iteration #1 completed in 147.89ms.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh tolerance met in mesh iteration 1.\n", + "\n", + "\n", + "===========================================\n", + "Optimal control problem sucessfully solved.\n", + "===========================================\n", + "\n", + "Final Objective Function Evaluation: 1.1547\n", + "\n" + ] + } + ], + "source": [ + "problem.initialise()\n", + "problem.solve()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0c5a3c66", + "metadata": {}, + "source": [ + "## Solution\n", + "All results can be found in the `OCP_instance.solution`, see [next example](BlockSlide_2.rst) for accessing the solution." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/Examples/BlockSlide_2.ipynb b/docs/Examples/BlockSlide_2.ipynb new file mode 100644 index 0000000..24fbd7e --- /dev/null +++ b/docs/Examples/BlockSlide_2.ipynb @@ -0,0 +1,478 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiphase" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## OCP Description\n", + "Let's introduce a second phase to the previous example where the block will have to return to it's original position. Because we know friction will switch direction when we slide the block back, the equations of motion change. One way of solving this optimization is to use a continious boolean function such as a [sigmoid function](https://en.wikipedia.org/wiki/Sigmoid_function). Due to the higher order optimization scheme pycollo uses, these functions are numerically unstable. Because we know when the equations change we can split up the optimization in two continious time phases to tackle this problem! Since phase A will not change, lets copy everything up until we start initiating the objective function. " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "# 1D Blockslide\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import sympy as sym\n", + "import pycollo\n", + "\n", + "# State variables\n", + "x = sym.Symbol(\"x\") # Position (m) of the block horizontally from the origin (x-axis)\n", + "dx = sym.Symbol(\"dx\") # Velocity (m/s) of the block horizontally (x-axis)\n", + "# Control variables\n", + "Fx = sym.Symbol(\"Fx\") # Force (N) applied to the block horizontally (x-axis)\n", + "\n", + "# Static parameter variable\n", + "g = sym.Symbol(\"g\") # Gravitational acceleration (m/s^2)\n", + "m = sym.Symbol(\"m\") # Mass (kg) of the block\n", + "mu = sym.Symbol(\"mu\") # Coefficient of friction (-)\n", + "\n", + "# Problem instantiation\n", + "problem = pycollo.OptimalControlProblem(\n", + " name=\"Simple Block Slide\",\n", + " parameter_variables= (m,mu))\n", + " \n", + "problem.bounds.parameter_variables = [[1,2], [0.5,1]]\n", + "problem.guess.parameter_variables = [1.5, 0.75]\n", + "problem.auxiliary_data = {g: 9.81}\n", + "\n", + "phase_A = problem.new_phase(name=\"A\")\n", + "phase_A.bounds.initial_time = 0.1\n", + "phase_A.bounds.final_time = [0.1, 10]\n", + "phase_A.guess.time = [0.1, 1]\n", + "\n", + "phase_A.state_variables = [x, dx]\n", + "phase_A.bounds.state_variables = [[-3,3],[-50,50]]\n", + "phase_A.bounds.state_variables = {\n", + " x: [-3, 3],\n", + " dx: [-50, 50],}\n", + "phase_A.bounds.initial_state_constraints = {\n", + " x: 0,\n", + " dx: 0,}\n", + "phase_A.bounds.final_state_constraints = {\n", + " x: 1,\n", + " dx: 0,}\n", + "phase_A.guess.state_variables = [[0, 0], [0, 0]]\n", + "\n", + "phase_A.control_variables = [Fx]\n", + "phase_A.bounds.control_variables = {\n", + " Fx: [-50, 50],}\n", + "phase_A.guess.control_variables = [\n", + " [0, 0],]\n", + "\n", + "phase_A.state_equations = {\n", + " x: dx,\n", + " dx: Fx / m - m*g*mu,}\n", + "\n", + "phase_A.integrand_functions = [Fx ** 2]\n", + "phase_A.bounds.integral_variables = [[0, 1000]]\n", + "phase_A.guess.integral_variables = [0]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## New phase\n", + "Now we can copy the previous phase completely to initiate a new phase completely the same. When doing this make sure you overwrite everything that changes in this next phase. It is real easy to make mistakes like this and it is recommended to write out the full phase description as depicted above." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "phase_B = problem.new_phase_like(\n", + " phase_for_copying=phase_A,\n", + " name=\"B\",)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can start overwriting everything that will be different from the previous phase:\n", + "\n", + "- Time \n", + " Phase B initial time can start any moment within bounds, final time the same\n", + "- Initial and final state constraints\n", + " The block starts at final state of phase A, and will end at 0.\n", + "- State equations\n", + " Friction changes sign" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "# Time \n", + "phase_B.bounds.initial_time = [0, 10]\n", + "phase_B.bounds.final_time = [0, 10]\n", + "phase_B.guess.time = [1, 2]\n", + "\n", + "# Initial and final state constraints\n", + "phase_B.bounds.initial_state_constraints = {\n", + " x: 1,\n", + " dx: 0,}\n", + "phase_B.bounds.final_state_constraints = {\n", + " x: 0,\n", + " dx: 0,}\n", + "\n", + "# State equations\n", + "phase_B.state_equations = {\n", + " x: dx,\n", + " dx: Fx / m + m*g*mu,}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Endpoint constraints\n", + "To make sure all variables are continious, sometimes endpoint constraints need to be implemented. Endpoint constraints are constraintes which exist of initial and final variables. When final and initial states are not bound to a single value, phase A final states should match phase B initial states to make the states continious. In this example, the states are constrainted to be continious due to the initial and final state constraints of both phases. Time variables are not constrained to be continious (yet) thus we can implement the following inequality constraint (final time phase A = initial time phase B -> final time phase A - initial time phase B = 0):" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "problem.endpoint_constraints = [\n", + " phase_A.final_time_variable - phase_B.initial_time_variable,]\n", + " \n", + "problem.bounds.endpoint_constraints = [\n", + " 0,]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Objective function - multiphase\n", + "Now the objective to minimize input force Fx should als be updated to consider both phases, the integrand functions are created with the copying of the new phase but are yet to be implemented in the objective:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "problem.objective_function = (\n", + " phase_A.integral_variables[0] + phase_B.integral_variables[0])\n", + "# Bug\n", + "phase_B.guess.integral_variables = 0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solve" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=====================================\n", + "Initialising optimal control problem.\n", + "=====================================\n", + "\n", + "Phase variables and equations checked.\n", + "Pycollo variables and constraints preprocessed.\n", + "Backend initialised.\n", + "Bounds checked.\n", + "Problem scaling initialised.\n", + "Quadrature scheme initialised.\n", + "Backend postprocessing complete.\n", + "Initial mesh created.\n", + "Initial guess checked.\n", + "\n", + "===============================\n", + "Initialising mesh iteration #1.\n", + "===============================\n", + "\n", + "Guess interpolated to iteration mesh in 707.62us.\n", + "Scaling initialised in 75.96us.\n", + "Initial guess scaled in 3.96us.\n", + "Scaling generated in 3.02ms.\n", + "NLP generated in 61.01ms.\n", + "Mesh-specific bounds generated in 284.37us.\n", + "\n", + "Mesh iteration #1 initialised in 65.10ms.\n", + "\n", + "\n", + "==========================\n", + "Solving mesh iteration #1.\n", + "==========================\n", + "\n", + "This is Ipopt version 3.14.11, running with linear solver MUMPS 5.2.1.\n", + "\n", + "Number of nonzeros in equality constraint Jacobian...: 1061\n", + "Number of nonzeros in inequality constraint Jacobian.: 0\n", + "Number of nonzeros in Lagrangian Hessian.............: 312\n", + "\n", + "Total number of variables............................: 185\n", + " variables with only lower bounds: 0\n", + " variables with lower and upper bounds: 185\n", + " variables with only upper bounds: 0\n", + "Total number of equality constraints.................: 123\n", + "Total number of inequality constraints...............: 0\n", + " inequality constraints with only lower bounds: 0\n", + " inequality constraints with lower and upper bounds: 0\n", + " inequality constraints with only upper bounds: 0\n", + "\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 0 1.9999980e+01 1.67e-01 0.00e+00 0.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", + " 1 1.9998000e-01 2.22e-02 1.36e+02 -6.3 1.73e-01 - 7.43e-01 9.90e-01f 1\n", + " 2 3.5613274e+00 2.19e-02 1.43e+02 -0.7 4.49e+01 - 1.26e-02 9.64e-03h 1\n", + " 3 1.4312428e+01 2.09e-02 2.09e+03 0.7 1.63e+01 - 1.00e+00 4.43e-02f 1\n", + " 4 1.7102938e+01 1.88e-02 8.36e+02 1.6 4.82e+00 - 1.00e+00 1.02e-01f 2\n", + " 5 1.7584938e+02 7.41e-02 3.00e+03 1.9 4.61e-01 - 6.78e-01 1.00e+00f 1\n", + " 6 8.6554096e+01 9.33e-02 3.16e+03 2.0 3.13e-01 - 9.30e-01 7.82e-01f 1\n", + " 7 6.8388194e+01 4.87e-02 1.14e+03 -4.1 2.38e-01 - 6.98e-01 6.96e-01f 1\n", + " 8 1.4518747e+02 1.33e-02 6.77e+01 -0.1 1.06e-01 2.0 8.69e-01 1.00e+00h 1\n", + " 9 1.0781707e+02 8.15e-03 1.88e+01 -0.4 7.12e-02 - 9.94e-01 1.00e+00f 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 10 6.3396663e+01 5.93e-03 3.20e+00 -1.0 1.24e-01 - 9.97e-01 1.00e+00f 1\n", + " 11 7.1525505e+01 7.02e-05 1.51e-01 -1.4 1.69e-02 - 9.80e-01 1.00e+00h 1\n", + " 12 7.0965586e+01 4.90e-06 4.25e-03 -3.3 2.60e-03 - 1.00e+00 1.00e+00f 1\n", + " 13 7.0958272e+01 2.19e-08 1.96e-05 -9.3 9.17e-05 - 9.96e-01 9.96e-01h 1\n", + " 14 7.0958243e+01 3.92e-13 3.34e-10 -11.0 3.94e-07 - 1.00e+00 1.00e+00h 1\n", + " 15 7.0958243e+01 4.63e-17 4.09e-14 -11.0 6.77e-12 - 1.00e+00 1.00e+00h 1\n", + "\n", + "Number of Iterations....: 15\n", + "\n", + " (scaled) (unscaled)\n", + "Objective...............: 7.0958242992066296e+00 7.0958242992066289e+01\n", + "Dual infeasibility......: 4.0902602494212730e-14 4.0902602494212730e-13\n", + "Constraint violation....: 4.6259292692714852e-17 4.6259292692714852e-17\n", + "Variable bound violation: 9.9995973723565612e-09 9.9995973723565612e-09\n", + "Complementarity.........: 1.0000660573769794e-11 1.0000660573769793e-10\n", + "Overall NLP error.......: 1.0000660573769794e-11 1.0000660573769793e-10\n", + "\n", + "\n", + "Number of objective function evaluations = 18\n", + "Number of objective gradient evaluations = 16\n", + "Number of equality constraint evaluations = 18\n", + "Number of inequality constraint evaluations = 0\n", + "Number of equality constraint Jacobian evaluations = 16\n", + "Number of inequality constraint Jacobian evaluations = 0\n", + "Number of Lagrangian Hessian evaluations = 15\n", + "Total seconds in IPOPT = 0.020\n", + "\n", + "EXIT: Optimal Solution Found.\n", + " solver : t_proc (avg) t_wall (avg) n_eval\n", + " nlp_f | 21.00us ( 1.17us) 16.50us (916.78ns) 18\n", + " nlp_g | 256.00us ( 14.22us) 241.17us ( 13.40us) 18\n", + " nlp_grad_f | 34.00us ( 1.89us) 29.33us ( 1.63us) 18\n", + " nlp_hess_l | 454.00us ( 30.27us) 452.79us ( 30.19us) 15\n", + " nlp_jac_g | 610.00us ( 35.88us) 608.04us ( 35.77us) 17\n", + " total | 20.82ms ( 20.82ms) 20.82ms ( 20.82ms) 1\n", + "\n", + "==================================\n", + "Post-processing mesh iteration #1.\n", + "==================================\n", + "\n", + "Mesh iteration #1 solved in 21.12ms.\n", + "Mesh iteration #1 post-processed in 43.58ms.\n", + "\n", + "\n", + "============================\n", + "Analysing mesh iteration #1.\n", + "============================\n", + "\n", + "Objective Evaluation: 70.95824299206629\n", + "Max Relative Mesh Error: 3.346404119354617e-16\n", + "Collocation Points Used: 62\n", + "\n", + "Adjusting Collocation Mesh: [10, 10] mesh sections\n", + "\n", + "Mesh iteration #1 completed in 129.79ms.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh tolerance met in mesh iteration 1.\n", + "\n", + "\n", + "===========================================\n", + "Optimal control problem sucessfully solved.\n", + "===========================================\n", + "\n", + "Final Objective Function Evaluation: 70.9582\n", + "\n" + ] + } + ], + "source": [ + "problem.settings.display_mesh_result_graph = True\n", + "problem.initialise()\n", + "problem.solve()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Solution\n", + "To acces the found solution you can use `problem.solution.{}`. The most frequently used options are: \n", + "\n", + "- `problem.solution.state`\n", + " Outputs a tuple where each index represents the solution per phase. The solution per phase is presented by an array for each state variable where the indices of these arrays represent the solution at the given collocation point. The solutions are ordered the same way you supplied the state variables.For example: In this case there are 2 phases (A and B), and 2 states ($x$, $dx$) with each 31 collocation points. Thus `problem.solution.state[0][1][23]` will output the 23rd collocation point of state variable $dx$ of phase A. " + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'A': Phase(OptimalControlProblem('Simple Block Slide'), phase_number=0), 'B': Phase(OptimalControlProblem('Simple Block Slide'), phase_number=1)}\n", + "(x, dx)\n", + "(2, 2, 31)\n", + "0.95381151865818\n" + ] + } + ], + "source": [ + "print(problem.phases)\n", + "print(phase_A.state_variables)\n", + "print(np.shape(problem.solution.state))\n", + "print(problem.solution.state[0][1][23])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- `problem.solution.control`\n", + " Shows solution of all control variables indexed the same as shown above\n", + "- `problem.solution.parameter`\n", + " Outputs 1D numpy array of parameters in the order you have supplied them to the OCP.\n", + "- `problem.solution.integral`\n", + " Outputs a tuple where each index represents the solution per phase. The solution per phase is presented by an array where each element represents the solution of the integrand function in that phase. For example in this case there is only one integrand function, the first array is the solution for phase A and the second array for phase B:" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(Fx**2,)\n", + "(array([35.4791215]), array([35.4791215]))\n" + ] + } + ], + "source": [ + "print(phase_A.integrand_functions)\n", + "print(problem.solution.integral)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- `problem.solution.\\_time\\_`\\\n", + " Outputs a tuple where each index represents the time per phase. The time per phase is a 1D array where every index indicates the time at that collocation point.\n", + "- `problem.solution.initial time`\n", + " Outputs tuple of initial times per phase\n", + "- `problem.solution.final time`\n", + " Outputs tuple of final times per phase" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/Examples/BlockSlide_3.ipynb b/docs/Examples/BlockSlide_3.ipynb new file mode 100644 index 0000000..87afcca --- /dev/null +++ b/docs/Examples/BlockSlide_3.ipynb @@ -0,0 +1,631 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Path and Endpoint Constraints" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## OCP Description\n", + "This example will show a more complex path constraint and how endpoint constraints are handeled. This example could be single phase because the dynamics do not change and all states are continious, but to explain how the endpoint constraints work the problem is split up into 2 phases. \n", + "\n", + "For this example we will introduce an extra dimension compared to the previous example. Now the block can slide in 2D. We will assume the block is on 4 cartwheels and can move freely without friction. Lets add linear drag in both directions with a coefficient of friction of 1.05. The block starts at (1,-2) with zero speed, should reach the mid position (0,2) with any given speed, and final position (-1,-2) with zero speed, while dodging an circular object with a radius of 1[m] at (0,0) while minimizing input force." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 2D Blockslide\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import sympy as sym\n", + "import pycollo\n", + "\n", + "# State variables\n", + "x = sym.Symbol(\"x\") # Position (m) of the point horizontally from the origi(x-axis)\n", + "dx = sym.Symbol(\"dx\") # Velocity (m/s) of the point horizontally (x-axis)\n", + "# Control variables\n", + "y = sym.Symbol(\"y\") # Position (m) of the point horizontally from the origi(x-axis)\n", + "dy = sym.Symbol(\"dy\") # Velocity (m/s) of the point horizontally (x-axis)\n", + "# Control variables\n", + "Fx = sym.Symbol(\"Fx\") # Force (N) applied to the point horizontally (x-axis)\n", + "Fy = sym.Symbol(\"Fy\") # Force (N) applied to the point horizontally (x-axis)\n", + "\n", + "r = 1.0\n", + "b = 1.05\n", + "\n", + "# Static parameter variable\n", + "m = sym.Symbol(\"m\") # Mass (kg) of the point\n", + "\n", + "# Problem instantiation\n", + "problem = pycollo.OptimalControlProblem(\n", + " name=\"2D Block Slide\",\n", + " parameter_variables= (m)\n", + " )\n", + "problem.bounds.parameter_variables = [[1,2]]\n", + "problem.guess.parameter_variables = [1.5]\n", + "\n", + "phase_A = problem.new_phase(name=\"A\")\n", + "phase_A.bounds.initial_time = 0\n", + "phase_A.bounds.final_time = [0, 10]\n", + "phase_A.guess.time = [0, 1]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## States and Control\n", + "State bounds, control, and integrand functions will be the same as the previous example but with an added dimension ($y$). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "phase_A.state_variables = [x, y, dx, dy]\n", + "phase_A.bounds.state_variables = [[-3,3],[-50,50]]\n", + "phase_A.bounds.state_variables = {\n", + " x: [-3, 3],\n", + " y: [-3, 3],\n", + " dx: [-50, 50],\n", + " dy: [-50, 50],}\n", + "\n", + "phase_A.control_variables = [Fx, Fy]\n", + "phase_A.bounds.control_variables = {\n", + " Fx: [-50, 50], \n", + " Fy: [-50,50]}\n", + "phase_A.guess.control_variables = [\n", + " [0, 0],[0, 0]]\n", + "\n", + "phase_A.integrand_functions = [Fx ** 2, Fy**2 ]\n", + "phase_A.bounds.integral_variables = [[0, 1000],[0,1000]]\n", + "phase_A.guess.integral_variables = [[0],[0]]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will split the two phases by the two checkpoints the block should reach. The first phase will terminate at the midpoint. Final state of dx and dy should be unconstrained and are set at the same limit as the statebounds. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.bounds.initial_state_constraints = {\n", + " x: 1,\n", + " y: -2,\n", + " dx: 0,\n", + " dy: 0,}\n", + "phase_A.bounds.final_state_constraints = {\n", + " x: 0,\n", + " y: 2,\n", + " dx: [-50, 50],\n", + " dy: [-50, 50], }\n", + "phase_A.guess.state_variables = [[1, 0], [-2, 2], [0,0], [0,0]]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The state equations will be the same with an extra dimension and linear drag added to the equation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.state_equations = {\n", + " x: dx,\n", + " y: dy,\n", + " dx: Fx / m - b/m *dx,\n", + " dy: Fy / m - b/m *dy}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Path Constraints\n", + "Path constraints or inequality constraints, are constraints made up of continious time variables in contradiction with endpoint constraints. Path constraints are relatively hard to solve for the optimizer and should not be used when not necessary. \n", + "\n", + "The circular object with radius 1[m] located at (0,0) can be made with an inequality constraint. With the circle equation we can make sure $x$ and $y$ will be out of the circle at any time within phase A with a maximum of 10[m] distance. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_A.path_constraints = [sym.sqrt(x ** 2 + y ** 2) - r]\n", + "phase_A.bounds.path_constraints = [[0, 10]]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## New phase\n", + "Now we can copy the previous phase completely to initiate a new phase completely the same. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_B = problem.new_phase_like(\n", + " phase_for_copying=phase_A,\n", + " name=\"B\",)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we overwrite everything that will be different from the last phase\n", + "\n", + "- Time \n", + " Phase B initial time can start any moment within bounds, final time the same\n", + "- Initial and final state constraints\n", + " The initial condition of phase B should be the same as the final state as phase A. The final location and speeds are implemented as described in the OCP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Time \n", + "phase_B.bounds.initial_time = [0, 10]\n", + "phase_B.bounds.final_time = [0, 10]\n", + "phase_B.guess.time = [1, 2]\n", + "\n", + "# Initial and final state constraints\n", + "phase_B.bounds.initial_state_constraints = phase_A.bounds.final_state_constraints\n", + "\n", + "phase_B.bounds.final_state_constraints = {\n", + " x: -1,\n", + " y: -2,\n", + " dx: 0,\n", + " dy: 0,}" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Endpoint constraints\n", + "To make sure all variables are continious, sometimes endpoint constraints need to be implemented. Endpoint constraints are constraintes which exist of initial and final variables. When final and initial states are not bound to a single value, phase A final states should match phase B initial states to make the states continious. Time variables are not constrained to be continious (yet), thus we can implement the following inequality constraint (final time phase A = initial time phase B -> final time phase A - initial time phase B = 0). In this example, $x$ and $y$ are constrainted to be continious due to the initial and final state constraints of both phases. The only constraint we'd like to implement to $dx$ and $dy$ is that the endpoints are corresponding and thus continious. This is done similarly as time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "problem.endpoint_constraints = [\n", + " phase_A.final_time_variable - phase_B.initial_time_variable,\n", + " phase_A.final_state_variables.dx - phase_B.initial_state_variables.dx,\n", + " phase_A.final_state_variables.dy - phase_B.initial_state_variables.dy,]\n", + "problem.bounds.endpoint_constraints = [\n", + " 0,\n", + " 0,\n", + " 0,]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Objective function \n", + "Minimizing input forces is realised with the integrated functions of phase A and phase B" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "problem.objective_function = (\n", + " phase_A.integral_variables[0] +phase_A.integral_variables[1] + phase_B.integral_variables[0] + phase_B.integral_variables[1])\n", + "# Bug\n", + "phase_B.guess.integral_variables = [[0],[0]]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Settings\n", + "To converge quicker in this relatively simple OCP, lets reduce the NLP tolerance and mesh tolerance. And lets add more collocations points by increasing the number of mesh sections to account for the lower tolerances." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "problem.settings.display_mesh_result_graph = True\n", + "problem.settings.nlp_tolerance = 1e-8\n", + "problem.settings.mesh_tolerance = 1e-6\n", + "\n", + "phase_A.mesh.number_mesh_sections = 30\n", + "phase_B.mesh.number_mesh_sections = 30" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solve and Plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=====================================\n", + "Initialising optimal control problem.\n", + "=====================================\n", + "\n", + "Phase variables and equations checked.\n", + "Pycollo variables and constraints preprocessed.\n", + "Backend initialised.\n", + "Bounds checked.\n", + "Problem scaling initialised.\n", + "Quadrature scheme initialised.\n", + "Backend postprocessing complete.\n", + "Initial mesh created.\n", + "Initial guess checked.\n", + "\n", + "===============================\n", + "Initialising mesh iteration #1.\n", + "===============================\n", + "\n", + "Guess interpolated to iteration mesh in 902.04us.\n", + "Scaling initialised in 69.08us.\n", + "Initial guess scaled in 9.08us.\n", + "Scaling generated in 99.30ms.\n", + "NLP generated in 663.97ms.\n", + "Mesh-specific bounds generated in 757.21us.\n", + "\n", + "Mesh iteration #1 initialised in 765.01ms.\n", + "\n", + "\n", + "==========================\n", + "Solving mesh iteration #1.\n", + "==========================\n", + "\n", + "\n", + "******************************************************************************\n", + "This program contains Ipopt, a library for large-scale nonlinear optimization.\n", + " Ipopt is released as open source code under the Eclipse Public License (EPL).\n", + " For more information visit https://github.com/coin-or/Ipopt\n", + "******************************************************************************\n", + "\n", + "This is Ipopt version 3.14.11, running with linear solver MUMPS 5.2.1.\n", + "\n", + "Number of nonzeros in equality constraint Jacobian...: 6820\n", + "Number of nonzeros in inequality constraint Jacobian.: 356\n", + "Number of nonzeros in Lagrangian Hessian.............: 2712\n", + "\n", + "Total number of variables............................: 1088\n", + " variables with only lower bounds: 0\n", + " variables with lower and upper bounds: 1088\n", + " variables with only upper bounds: 0\n", + "Total number of equality constraints.................: 727\n", + "Total number of inequality constraints...............: 182\n", + " inequality constraints with only lower bounds: 0\n", + " inequality constraints with lower and upper bounds: 182\n", + " inequality constraints with only upper bounds: 0\n", + "\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 0 3.9999960e+01 6.61e-01 0.00e+00 0.0 0.00e+00 - 0.00e+00 0.00e+00 0\n", + " 1 3.8935008e+01 6.43e-01 7.75e+00 -1.4 6.76e-01 - 2.15e-01 2.66e-02h 1\n", + " 2 3.8974545e+01 6.41e-01 1.38e+02 -6.4 4.90e+00 - 3.36e-02 2.27e-03h 1\n", + " 3 4.2225887e+01 5.78e-01 4.58e+02 -0.0 7.83e+00 - 3.06e-02 9.97e-02f 1\n", + " 4 4.9172584e+01 5.02e-01 3.61e+02 -0.5 6.49e-01 2.0 3.30e-02 1.31e-01h 1\n", + " 5 5.0587662e+01 4.96e-01 4.27e+02 0.0 6.52e-01 2.4 1.00e+00 1.16e-02h 1\n", + " 6 5.0408344e+01 4.96e-01 2.22e+03 -6.0 2.33e+01 1.9 4.28e-03 8.43e-04h 1\n", + " 7 3.2969406e+01 4.85e-01 7.45e+03 0.4 1.98e+01 2.4 7.31e-03 2.16e-02f 1\n", + " 8 2.3383650e+01 4.80e-01 1.29e+04 1.7 1.80e+01 1.9 4.06e-02 1.05e-02f 1\n", + " 9 2.3823631e+01 4.79e-01 1.02e+04 -5.5 4.74e+00 2.3 2.66e-02 7.01e-04h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 10 1.6020282e+02 4.74e-01 1.24e+04 1.8 1.10e+01 1.8 5.66e-02 1.06e-02f 1\n", + " 11 1.6191471e+02 4.74e-01 9.90e+03 0.7 4.87e+00 1.4 4.33e-02 7.91e-04h 1\n", + " 12 3.3882461e+02 4.69e-01 1.03e+04 1.7 2.50e+01 0.9 3.74e-02 1.05e-02f 1\n", + " 13 3.9423835e+02 4.65e-01 6.02e+03 0.8 7.65e+00 1.3 2.41e-02 7.93e-03h 1\n", + " 14 4.7231450e+02 4.61e-01 2.29e+03 0.8 4.53e+00 - 2.17e-02 8.78e-03h 1\n", + " 15 1.0101825e+03 5.54e-01 9.06e+03 1.6 6.28e+00 - 2.56e-02 4.78e-02f 1\n", + " 16 1.1298699e+03 5.52e-01 6.54e+03 0.8 1.33e+01 - 2.95e-02 5.34e-03h 1\n", + " 17 1.4867296e+03 5.59e-01 3.56e+04 0.8 1.49e+01 - 4.61e-02 1.41e-02h 1\n", + " 18 1.8693397e+03 5.76e-01 1.34e+05 0.8 1.13e+01 - 5.73e-02 1.46e-02h 1\n", + " 19 2.0313076e+03 5.80e-01 3.24e+05 0.8 1.25e+01 - 2.59e-02 6.04e-03h 2\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 20 2.1447700e+03 5.85e-01 1.18e+06 0.8 1.74e+01 - 3.55e-02 3.13e-03h 3\n", + " 21 2.2711822e+03 5.94e-01 2.53e+06 0.8 2.56e+01 - 1.94e-02 2.69e-03h 3\n", + " 22 2.3988182e+03 6.01e-01 4.95e+06 0.8 3.25e+01 - 1.28e-02 2.47e-03h 3\n", + " 23 2.5834848e+03 6.12e-01 8.14e+06 0.8 6.99e+01 - 7.84e-03 3.11e-03h 2\n", + " 24 2.6902753e+03 6.13e-01 1.59e+07 2.7 1.35e+02 1.7 4.69e-03 1.50e-03h 2\n", + " 25 2.6957093e+03 6.13e-01 2.82e+07 2.7 3.28e+02 - 1.91e-03 5.62e-05h 5\n", + " 26 2.7750384e+03 6.14e-01 3.82e+07 2.7 2.32e+02 - 1.80e-03 7.96e-04h 2\n", + " 27 2.8608220e+03 6.14e-01 4.31e+07 2.7 5.87e+02 - 9.63e-04 7.17e-04h 1\n", + " 28 2.8972811e+03 6.14e-01 8.11e+07 2.7 3.96e+02 - 1.23e-03 2.64e-04h 1\n", + " 29 2.9531042e+03 6.15e-01 1.02e+08 2.7 1.21e+03 - 7.17e-04 4.24e-04h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 30 2.9708526e+03 6.15e-01 1.56e+08 2.7 1.21e+03 - 5.02e-04 1.19e-04h 3\n", + " 31 2.9862700e+03 6.14e-01 2.23e+08 2.7 1.22e+03 - 4.05e-04 8.86e-05h 3\n", + " 32 2.9929998e+03 6.14e-01 5.36e+08 2.7 1.18e+03 - 1.05e-03 3.44e-05h 4\n", + " 33 3.0075096e+03 6.14e-01 1.04e+09 2.7 9.95e+02 - 8.90e-04 7.14e-05h 3\n", + " 34r 3.0075096e+03 6.14e-01 9.99e+02 2.7 0.00e+00 - 0.00e+00 3.50e-07R 11\n", + " 35r 3.0570576e+03 2.34e-01 2.10e+02 1.4 1.60e+00 - 9.04e-01 6.14e-01f 1\n", + " 36 2.9365457e+03 2.32e-01 9.89e+01 -0.4 3.43e+00 - 1.09e-02 1.67e-02f 1\n", + " 37 1.3196000e+03 6.25e-01 9.53e+01 -0.4 2.06e+01 - 7.15e-03 4.38e-02f 1\n", + " 38 1.0828491e+03 6.10e-01 9.17e+01 -0.4 8.07e+00 - 5.28e-02 2.46e-02f 1\n", + " 39 9.8455360e+02 5.81e-01 8.67e+01 -0.4 1.09e+00 - 1.48e-01 5.09e-02f 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 40 4.6864443e+02 5.14e-01 1.53e+02 -0.4 3.42e+00 - 2.70e-01 1.68e-01f 1\n", + " 41 2.8512954e+01 4.16e-01 5.24e+01 -0.4 9.39e-01 - 3.02e-01 3.26e-01f 1\n", + " 42 1.0894605e+02 3.46e-01 8.80e+01 0.0 5.77e-01 - 6.27e-01 5.20e-01f 1\n", + " 43 1.1578609e+02 2.64e-01 8.02e+01 -6.1 2.86e-01 2.2 2.08e-01 2.62e-01h 1\n", + " 44 1.0854967e+02 1.64e-01 6.34e+01 -1.5 2.26e-01 1.7 2.92e-01 5.08e-01f 1\n", + " 45 5.0814810e+01 9.44e-02 2.76e+01 -1.7 2.37e-01 - 5.95e-01 7.04e-01f 1\n", + " 46 3.9463594e+01 6.75e-02 2.25e+01 -6.7 3.07e-01 - 1.32e-01 3.87e-01f 1\n", + " 47 3.8046100e+01 5.29e-02 2.36e+01 -2.8 2.79e-01 - 1.06e-01 2.65e-01h 1\n", + " 48 3.9032495e+01 3.82e-02 3.12e+01 -2.9 2.35e-01 - 1.24e-01 3.31e-01h 1\n", + " 49 4.0960726e+01 2.68e-02 3.94e+01 -2.7 2.27e-01 - 1.02e-01 3.27e-01h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 50 4.2906986e+01 2.03e-02 3.67e+01 -3.0 2.07e-01 - 8.98e-02 2.56e-01h 1\n", + " 51 4.5245259e+01 1.37e-02 3.34e+01 -3.0 1.83e-01 - 9.78e-02 3.50e-01h 1\n", + " 52 4.6677569e+01 8.45e-03 3.48e+01 -3.1 1.53e-01 - 8.52e-02 4.16e-01h 1\n", + " 53 4.6906645e+01 5.55e-03 2.88e+01 -3.1 1.11e-01 - 8.02e-02 3.78e-01h 1\n", + " 54 4.5526112e+01 3.21e-03 2.10e+01 -3.2 8.84e-02 - 8.13e-02 4.88e-01h 1\n", + " 55 4.2235836e+01 1.83e-03 1.83e+01 -3.2 9.44e-02 - 6.68e-02 5.29e-01h 1\n", + " 56 4.0095086e+01 1.34e-03 1.77e+01 -7.1 1.05e-01 - 6.17e-02 3.15e-01h 1\n", + " 57 3.6609963e+01 9.07e-04 1.73e+01 -3.2 1.16e-01 - 4.83e-02 4.44e-01h 1\n", + " 58 3.4070772e+01 7.30e-04 1.66e+01 -7.2 1.26e-01 - 4.99e-02 3.12e-01h 1\n", + " 59 2.6013338e+01 1.64e-03 2.23e+01 -3.3 1.36e-01 - 5.46e-02 9.40e-01f 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 60 2.3847931e+01 1.25e-03 1.39e+01 -7.2 1.04e-01 - 1.42e-01 3.79e-01h 1\n", + " 61 2.1431445e+01 1.05e-03 1.21e+01 -7.3 1.09e-01 - 1.22e-01 3.51e-01h 1\n", + " 62 2.0907476e+01 9.54e-04 1.14e+01 -7.3 7.20e-02 - 6.22e-02 9.92e-02h 1\n", + " 63 1.9852037e+01 8.32e-04 1.38e+01 -3.5 8.24e-02 - 3.59e-02 1.56e-01h 1\n", + " 64 1.8079014e+01 6.03e-04 1.97e+01 -3.1 7.38e-02 - 5.74e-02 3.30e-01h 1\n", + " 65 1.6616044e+01 4.35e-04 1.12e+01 -3.5 6.38e-02 - 1.58e-01 4.13e-01h 1\n", + " 66 1.6064557e+01 3.72e-04 8.74e+00 -3.6 4.67e-02 - 7.81e-02 2.19e-01h 1\n", + " 67 1.5430606e+01 3.10e-04 7.87e+00 -3.6 4.17e-02 - 8.69e-02 2.85e-01h 1\n", + " 68 1.4863834e+01 2.55e-04 7.45e+00 -3.7 3.75e-02 - 8.60e-02 3.01e-01h 1\n", + " 69 1.4575695e+01 2.15e-04 7.03e+00 -3.7 3.00e-02 - 7.62e-02 2.10e-01h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 70 1.4240587e+01 1.76e-04 6.59e+00 -3.7 2.95e-02 - 9.05e-02 2.67e-01h 1\n", + " 71 1.3919494e+01 1.45e-04 6.14e+00 -3.8 2.95e-02 - 9.53e-02 2.86e-01h 1\n", + " 72 1.3746748e+01 1.23e-04 5.71e+00 -3.8 2.58e-02 - 8.53e-02 2.01e-01h 1\n", + " 73 1.3537014e+01 1.02e-04 5.22e+00 -3.8 2.61e-02 - 1.08e-01 2.61e-01h 1\n", + " 74 1.3331185e+01 8.43e-05 4.76e+00 -3.9 2.61e-02 - 1.11e-01 2.91e-01h 1\n", + " 75 1.3213554e+01 7.08e-05 4.18e+00 -3.9 2.29e-02 - 1.33e-01 2.20e-01h 1\n", + " 76 1.3064380e+01 6.03e-05 3.71e+00 -3.6 2.61e-02 - 1.30e-01 2.76e-01h 1\n", + " 77 1.2933825e+01 5.03e-05 3.25e+00 -3.9 2.46e-02 - 1.41e-01 2.97e-01h 1\n", + " 78 1.2862991e+01 4.26e-05 2.81e+00 -4.1 2.17e-02 - 1.43e-01 2.10e-01h 1\n", + " 79 1.2770843e+01 3.63e-05 2.48e+00 -4.0 2.42e-02 - 1.33e-01 2.75e-01h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 80 1.2680357e+01 2.80e-05 2.18e+00 -4.3 1.81e-02 - 1.51e-01 4.28e-01h 1\n", + " 81 1.2669287e+01 2.56e-05 2.01e+00 -8.2 1.24e-02 - 7.98e-02 9.02e-02h 1\n", + " 82 1.2638376e+01 2.19e-05 1.51e+00 -4.4 1.79e-02 - 2.44e-01 1.90e-01h 1\n", + " 83 1.2587338e+01 1.91e-05 1.35e+00 -4.5 2.13e-02 - 1.21e-01 3.06e-01h 1\n", + " 84 1.2584611e+01 1.78e-05 1.24e+00 -8.4 5.89e-03 - 8.42e-02 7.31e-02h 1\n", + " 85 1.2547781e+01 1.39e-05 1.06e+00 -4.6 1.50e-02 - 1.69e-01 4.50e-01h 1\n", + " 86 1.2546949e+01 1.32e-05 9.10e-01 -8.6 4.90e-03 - 1.33e-01 5.37e-02h 1\n", + " 87 1.2531887e+01 1.06e-05 6.80e-01 -4.7 1.39e-02 - 2.58e-01 3.38e-01h 1\n", + " 88 1.2531780e+01 9.89e-06 5.65e-01 -8.8 3.01e-03 - 1.63e-01 6.59e-02h 1\n", + " 89 1.2523494e+01 7.31e-06 4.55e-01 -4.9 1.07e-02 - 2.11e-01 4.74e-01h 1\n", + "iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n", + " 90 1.2525525e+01 4.00e-06 2.04e-01 -4.3 4.28e-03 - 9.83e-01 5.17e-01h 1\n", + " 91 1.2526183e+01 1.50e-06 1.27e-01 -6.0 1.58e-03 - 8.12e-01 6.55e-01h 1\n", + " 92 1.2527300e+01 1.34e-07 1.52e-03 -6.0 1.25e-03 - 1.00e+00 1.00e+00h 1\n", + " 93 1.2527419e+01 8.44e-10 1.62e-05 -7.4 9.75e-05 - 1.00e+00 1.00e+00h 1\n", + " 94 1.2527419e+01 1.98e-12 5.25e-08 -11.0 4.63e-06 - 1.00e+00 9.99e-01h 1\n", + " 95 1.2527419e+01 1.13e-16 9.33e-14 -11.0 1.02e-08 - 1.00e+00 1.00e+00h 1\n", + "\n", + "Number of Iterations....: 95\n", + "\n", + " (scaled) (unscaled)\n", + "Objective...............: 1.2527419300764677e+00 1.2527419300764677e+01\n", + "Dual infeasibility......: 9.3277689858951551e-14 9.3277689858951551e-13\n", + "Constraint violation....: 1.1275702593849246e-16 1.1275702593849246e-16\n", + "Variable bound violation: 9.9948653797810039e-09 9.9948653797810039e-09\n", + "Complementarity.........: 1.0000832936611967e-11 1.0000832936611967e-10\n", + "Overall NLP error.......: 1.0000832936611967e-11 1.0000832936611967e-10\n", + "\n", + "\n", + "Number of objective function evaluations = 143\n", + "Number of objective gradient evaluations = 96\n", + "Number of equality constraint evaluations = 143\n", + "Number of inequality constraint evaluations = 143\n", + "Number of equality constraint Jacobian evaluations = 97\n", + "Number of inequality constraint Jacobian evaluations = 97\n", + "Number of Lagrangian Hessian evaluations = 95\n", + "Total seconds in IPOPT = 0.511\n", + "\n", + "EXIT: Optimal Solution Found.\n", + " solver : t_proc (avg) t_wall (avg) n_eval\n", + " nlp_f | 220.00us ( 1.54us) 188.50us ( 1.32us) 143\n", + " nlp_g | 9.16ms ( 64.06us) 8.69ms ( 60.75us) 143\n", + " nlp_grad_f | 503.00us ( 5.13us) 474.92us ( 4.85us) 98\n", + " nlp_hess_l | 14.89ms (158.36us) 14.89ms (158.36us) 94\n", + " nlp_jac_g | 15.10ms (154.07us) 15.12ms (154.33us) 98\n", + " total | 514.34ms (514.34ms) 516.90ms (516.90ms) 1\n", + "\n", + "==================================\n", + "Post-processing mesh iteration #1.\n", + "==================================\n", + "\n", + "Mesh iteration #1 solved in 517.80ms.\n", + "Mesh iteration #1 post-processed in 306.07ms.\n", + "\n", + "\n", + "============================\n", + "Analysing mesh iteration #1.\n", + "============================\n", + "\n", + "Objective Evaluation: 12.527419300764677\n", + "Max Relative Mesh Error: 1.4289219484514472e-07\n", + "Collocation Points Used: 182\n", + "\n", + "Adjusting Collocation Mesh: [30, 30] mesh sections\n", + "\n", + "Mesh iteration #1 completed in 1.59s.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh tolerance met in mesh iteration 1.\n", + "\n", + "\n", + "===========================================\n", + "Optimal control problem sucessfully solved.\n", + "===========================================\n", + "\n", + "Final Objective Function Evaluation: 12.5274\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "problem.initialise()\n", + "problem.solve()\n", + "\n", + "## Plot\n", + "# Create obstacle coordinates\n", + "alpha = np.linspace(0, 2 * np.pi, 1000)\n", + "x_circle = r * np.cos(alpha)\n", + "y_circle = r * np.sin(alpha)\n", + "\n", + "# Plot obstacle and solution in plan view\n", + "x_P0 = problem.solution.state[0][0]\n", + "y_P0 = problem.solution.state[0][1]\n", + "x_P1 = problem.solution.state[1][0]\n", + "y_P1 = problem.solution.state[1][1]\n", + "plt.plot(x_P0, y_P0)\n", + "plt.plot(x_P1, y_P1)\n", + "plt.plot(x_circle, y_circle, color=\"#000000\")\n", + "plt.gca().set_aspect(\"equal\", adjustable=\"box\")\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here you can see the optimal trajectory through 3 points while minimising input and avoiding the circle. Blue indicates the first phase, orange the second phase." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/Examples/index.rst b/docs/Examples/index.rst new file mode 100644 index 0000000..6fe58f8 --- /dev/null +++ b/docs/Examples/index.rst @@ -0,0 +1,10 @@ +Examples +======== + +.. toctree:: + :titlesonly: + + BlockSlide_1.ipynb + BlockSlide_2.ipynb + BlockSlide_3.ipynb + \ No newline at end of file diff --git a/docs/api_reference.rst b/docs/api_reference.rst index 3a6ad05..fb5a325 100644 --- a/docs/api_reference.rst +++ b/docs/api_reference.rst @@ -1,13 +1,13 @@ -.. _api_reference: - -============= -API Reference -============= - -.. autosummary:: - :toctree: _autosummary - :recursive: - - pycollo.optimal_control_problem - pycollo.phase - +.. _api_reference: + +============= +API Reference +============= + +.. autosummary:: + :toctree: _autosummary + :recursive: + + pycollo.optimal_control_problem + pycollo.phase + diff --git a/docs/conf.py b/docs/conf.py index 0736b83..9b52e1b 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -1,58 +1,60 @@ -"""Configuration file for the Sphinx documentation builder. - -For the full list of built-in configuration values, see the documentation: -https://www.sphinx-doc.org/en/master/usage/configuration.html -""" -import pathlib -import sys - -# Add source folder to path for autodoc -path = pathlib.Path(__file__).parent.parent.absolute() -sys.path.insert(0, str(path)) - -# -- Project information ----------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information - -project = "Pycollo" -copyright = "2023, Sam Brockie" # noqa: A001 -author = "Sam Brockie" - -# -- General configuration --------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration - -extensions = [ - "sphinx.ext.napoleon", - "sphinx.ext.intersphinx", - "sphinx.ext.autodoc", - "sphinx.ext.autosummary", - "sphinx.ext.mathjax", - "sphinx.ext.viewcode", -] - -templates_path = ["_templates"] -exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] - -napoleon_google_docstring = True -napoleon_custom_sections = [("Explanation", "notes_style")] - -intersphinx_mapping = { - "cyipopt": ("https://cyipopt.readthedocs.io/en/stable/", None), - "matplotlib": ("https://matplotlib.org/stable/", None), - "numba": ("https://numba.readthedocs.io/en/stable/", None), - "numpy": ("https://numpy.org/doc/stable/", None), - "scipy": ("https://docs.scipy.org/doc/scipy/", None), - "sympy": ("https://docs.sympy.org/latest/", None), - "python": ("http://docs.python.org/3", None), -} - - -# -- Options for HTML output ------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output - -html_theme = "furo" - -html_theme_options = { - "source_edit_link": "https://github.com/brocksam/pycollo/", -} - -html_static_path = ["_static"] +"""Configuration file for the Sphinx documentation builder. + +For the full list of built-in configuration values, see the documentation: +https://www.sphinx-doc.org/en/master/usage/configuration.html +""" +import pathlib +import sys + +# Add source folder to path for autodoc +path = pathlib.Path(__file__).parent.parent.absolute() +sys.path.insert(0, str(path)) + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = "Pycollo" +copyright = "2023, Sam Brockie" # noqa: A001 +author = "Sam Brockie" + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + "sphinx.ext.napoleon", + "sphinx.ext.intersphinx", + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.mathjax", + "sphinx.ext.viewcode", + "nbsphinx", + +] + +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +napoleon_google_docstring = True +napoleon_custom_sections = [("Explanation", "notes_style")] + +intersphinx_mapping = { + "cyipopt": ("https://cyipopt.readthedocs.io/en/stable/", None), + "matplotlib": ("https://matplotlib.org/stable/", None), + "numba": ("https://numba.readthedocs.io/en/stable/", None), + "numpy": ("https://numpy.org/doc/stable/", None), + "scipy": ("https://docs.scipy.org/doc/scipy/", None), + "sympy": ("https://docs.sympy.org/latest/", None), + "python": ("http://docs.python.org/3", None), +} + + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = "furo" + +html_theme_options = { + "source_edit_link": "https://github.com/brocksam/pycollo/", +} + +html_static_path = ["_static"] \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst index 8732541..b04363d 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,8 +3,8 @@ Pycollo Documentation ===================== Pycollo: an Open-Source Package for Multi Phase Direct Collocation. -.. toctree:: +.. toctree:: :maxdepth: 2 - :titlesonly: - + + Examples/index api_reference diff --git a/docs/requirements.txt b/docs/requirements.txt index 6d41039..b8c4865 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,3 @@ furo>=2023.5.20 sphinx>=6.1.3 +nbsphinx>=0.9.2 \ No newline at end of file