notebook/07_blockSchemes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f1ca8d76",
   "metadata": {},
   "source": [
    "# `BlockScheme` to represent time integration methods\n",
    "\n",
    "Time-stepping methods are represented by objects inheriting from a base class `BlockScheme` defined in the `blockops.schemes` subpackage.\n",
    "This class implements a `getBlockOperators(lamDt, phiName, chiName)` method that returns two `BlockOperator` objects that represent the $\\phi$ and $\\chi$ block operators for one block, such that:\n",
    "\n",
    "$$\n",
    "\\phi {\\bf u}_{n+1} = \\chi {\\bf u}_{n}.\n",
    "$$\n",
    "\n",
    "The `getBlockOperators` method uses two abstract method that should be overwritten in the children classes :\n",
    "\n",
    "- `getBlockMatrices(lamDt)` : generate the block matrices for $\\phi$ and $\\chi$\n",
    "- `getBlockCosts()` : estimate costs for $\\phi$ and $\\chi$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e52a54a",
   "metadata": {},
   "source": [
    "All available time integration methods are registered in the `SCHEMES` dictionnary of the `blockops.schemes` subpackage. This dictionnary contains all available classes that inherit from `BlockScheme` to implement one given type of time-stepping method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2eee27af",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:51.365587Z",
     "iopub.status.busy": "2023-03-28T16:13:51.365258Z",
     "iopub.status.idle": "2023-03-28T16:13:52.011925Z",
     "shell.execute_reply": "2023-03-28T16:13:52.011400Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Collocation': blockops.schemes.coll.Collocation,\n",
       " 'RungeKutta': blockops.schemes.rk.RungeKutta}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from blockops.schemes import SCHEMES\n",
    "SCHEMES"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da9d7230",
   "metadata": {},
   "source": [
    "Here we can see that two time-stepping schemes are available, namely `Collocation` and `RungeKutta`. Those can be instantiated with a constructor having specific parameters, some inherited from the `BlockScheme` class, some specific to the time-stepping method."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9095ce46",
   "metadata": {},
   "source": [
    "## `Parameter` subclass to describe parameters\n",
    "\n",
    "Looking closely to the `RungeKutta` class, we can access all its parameters through its `PARAMS` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c8e35981",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.017762Z",
     "iopub.status.busy": "2023-03-28T16:13:52.017480Z",
     "iopub.status.idle": "2023-03-28T16:13:52.021342Z",
     "shell.execute_reply": "2023-03-28T16:13:52.020871Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nPoints': PositiveInteger(default=None),\n",
       " 'ptsType': MultipleChoices(default=EQUID),\n",
       " 'quadType': MultipleChoices(default=LOBATTO),\n",
       " 'form': MultipleChoices(default=Z2N),\n",
       " 'rkScheme': MultipleChoices(default=BE),\n",
       " 'nStepsPerPoint': PositiveInteger(default=1)}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rk = SCHEMES['RungeKutta']\n",
    "\n",
    "rk.PARAMS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dd1ffc7",
   "metadata": {},
   "source": [
    "Each parameter is represented by a specific `Parameter` class (defined in `blockops.utils.params` submodule), which stores:\n",
    "\n",
    "- the documentation for this parameter\n",
    "- what kind of value is expected\n",
    "- what are the current default for the class (`default=None` indicate non optional parameters)\n",
    "\n",
    "Concerning the `RungeKutta` scheme class, it requires several parameter, with only one (`nPoints`) that is not optional (_i.e_ don't have a pre-set default value).\n",
    "\n",
    "Two types of parameters are used, namely the `PositiveInteger` and `MultipleChoices` parameter class. In order to see what type of value are expected by those parameters,\n",
    "one can simply look at the docstring of those parameters classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "50f53584",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.026510Z",
     "iopub.status.busy": "2023-03-28T16:13:52.026241Z",
     "iopub.status.idle": "2023-03-28T16:13:52.030196Z",
     "shell.execute_reply": "2023-03-28T16:13:52.029684Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Accepts one (default strictly) positive integer'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rk.PARAMS['nPoints'].__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "49b79900",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.034726Z",
     "iopub.status.busy": "2023-03-28T16:13:52.034399Z",
     "iopub.status.idle": "2023-03-28T16:13:52.038786Z",
     "shell.execute_reply": "2023-03-28T16:13:52.038197Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Accepts different parameter values or parameter types'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rk.PARAMS['ptsType'].__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19cfbfb5",
   "metadata": {},
   "source": [
    "\n",
    "More information are also stored on the parameter itself. \n",
    "For instance, if we look at the `ptsType` parameter, we can look at its documentation looking at the `docs` attribute of the parameter class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2f6d8ff6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.042423Z",
     "iopub.status.busy": "2023-03-28T16:13:52.042118Z",
     "iopub.status.idle": "2023-03-28T16:13:52.046439Z",
     "shell.execute_reply": "2023-03-28T16:13:52.045672Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of points distribution (EQUID, LEGENDRE, ...). Possibilities are :\n",
      "- `EQUID` : equidistant point uniformly distributed on the block\n",
      "- `LEGENDRE` : points distribution from Legendre polynomials\n",
      "- `CHEBY-{i}` : points distribution from Chebychev polynomials of the\n",
      "`i`'th kind (`i in [1,2,3,4]`).\n"
     ]
    }
   ],
   "source": [
    "ptsType = rk.PARAMS['ptsType']\n",
    "print(ptsType.docs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96f69cd4",
   "metadata": {},
   "source": [
    "The default value of this parameter for this class is then stored in the `default` attribute of the parameter class (`None` if parameter is not optional):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1e240d70",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.050278Z",
     "iopub.status.busy": "2023-03-28T16:13:52.049833Z",
     "iopub.status.idle": "2023-03-28T16:13:52.055078Z",
     "shell.execute_reply": "2023-03-28T16:13:52.054294Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'EQUID'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ptsType.default"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d42cc24f",
   "metadata": {},
   "source": [
    "Each parameter class is implemented in the `blockops.utils.params` submodule, where one can see its particular implementation and eventual attributes.\n",
    "\n",
    "For instance, the `MultipleChoices` parameter class allows different values or parameter type, and those are stored in the `choices`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3f51dbdf",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.059341Z",
     "iopub.status.busy": "2023-03-28T16:13:52.058890Z",
     "iopub.status.idle": "2023-03-28T16:13:52.064989Z",
     "shell.execute_reply": "2023-03-28T16:13:52.064170Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['EQUID', 'LEGENDRE', 'CHEBY-1', 'CHEBY-2', 'CHEBY-3', 'CHEBY-4']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ptsType.choices"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8ad180f",
   "metadata": {},
   "source": [
    "Here we can see that the user can choose between `EQUID`, `LEGENDRE`, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fb1697e",
   "metadata": {},
   "source": [
    "## Accessing defaults and docs for all parameters\n",
    "\n",
    "As described before, each `BlockScheme` subclass stores its parameters in the `PARAMS` attribute, from which documentation and default values can be retrieved individually for each parameter.\n",
    "But additionally, those `BlockScheme` subclass also inherit from utility class methods allowing to retrieve defaults and docs for all parameters.\n",
    "\n",
    "For instance, looking at the `RungeKutta` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7c8bf49b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.080866Z",
     "iopub.status.busy": "2023-03-28T16:13:52.080355Z",
     "iopub.status.idle": "2023-03-28T16:13:52.086852Z",
     "shell.execute_reply": "2023-03-28T16:13:52.086046Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nPoints': None,\n",
       " 'ptsType': 'EQUID',\n",
       " 'quadType': 'LOBATTO',\n",
       " 'form': 'Z2N',\n",
       " 'rkScheme': 'BE',\n",
       " 'nStepsPerPoint': 1}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCHEMES['RungeKutta'].getParamsDefault()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7c2d6520",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.091380Z",
     "iopub.status.busy": "2023-03-28T16:13:52.090882Z",
     "iopub.status.idle": "2023-03-28T16:13:52.096437Z",
     "shell.execute_reply": "2023-03-28T16:13:52.095579Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- nPoints ---\n",
      "Number of time points in the block. Ignored if a custom list of points\n",
      "is given for `ptsType`.\n",
      "--- ptsType ---\n",
      "Type of points distribution (EQUID, LEGENDRE, ...). Possibilities are :\n",
      "- `EQUID` : equidistant point uniformly distributed on the block\n",
      "- `LEGENDRE` : points distribution from Legendre polynomials\n",
      "- `CHEBY-{i}` : points distribution from Chebychev polynomials of the\n",
      "`i`'th kind (`i in [1,2,3,4]`).\n",
      "--- quadType ---\n",
      "Quadrature type used for the points in [0, 1]:\n",
      "- `LOBATTO` : 0 and 1 are included\n",
      "- `GAUSS` : neither 0 nor 1 are included\n",
      "- `RADAU-RIGHT` : only 1 is included\n",
      "- `RADAU-LEFT` : only 0 is included\n",
      "--- form ---\n",
      "Used formulation, can be either :\n",
      "- `Z2N` : zeros-to-nodes formulation, i.e the `chi` operator produces\n",
      "a vector of the form :math:`[u_0, u_0, ..., u_0]` and `phi` represents\n",
      "the integration from :math:`u_{0}` to each block time points (nodes).\n",
      "- `N2N` : node-to-node formulation, i.e the `chi` operator produces\n",
      "a vector of the form :math:`[u_0, 0, ..., 0]` and `phi` represents\n",
      "the integration from one time point (node) to the next one.\n",
      "--- rkScheme ---\n",
      "Name of the Runge-Kutta scheme (BE, FE, TRAP, RK4, ...).\n",
      "--- nStepsPerPoint ---\n",
      "Number of time-steps per block time point.\n"
     ]
    }
   ],
   "source": [
    "for param, doc in SCHEMES['RungeKutta'].getParamsDocs().items():\n",
    "    print(f'--- {param} ---')\n",
    "    print(doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b4fde10",
   "metadata": {},
   "source": [
    "Or for the `Collocation` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c2eae318",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.101525Z",
     "iopub.status.busy": "2023-03-28T16:13:52.101013Z",
     "iopub.status.idle": "2023-03-28T16:13:52.107358Z",
     "shell.execute_reply": "2023-03-28T16:13:52.106526Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nPoints': None,\n",
       " 'ptsType': 'LEGENDRE',\n",
       " 'quadType': 'LOBATTO',\n",
       " 'form': 'Z2N',\n",
       " 'collUpdate': False}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCHEMES['Collocation'].getParamsDefault()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b5cedc54",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.111872Z",
     "iopub.status.busy": "2023-03-28T16:13:52.111360Z",
     "iopub.status.idle": "2023-03-28T16:13:52.116887Z",
     "shell.execute_reply": "2023-03-28T16:13:52.116039Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- nPoints ---\n",
      "Number of time points in the block. Ignored if a custom list of points\n",
      "is given for `ptsType`.\n",
      "--- ptsType ---\n",
      "Type of points distribution (EQUID, LEGENDRE, ...). Possibilities are :\n",
      "- `EQUID` : equidistant point uniformly distributed on the block\n",
      "- `LEGENDRE` : points distribution from Legendre polynomials\n",
      "- `CHEBY-{i}` : points distribution from Chebychev polynomials of the\n",
      "`i`'th kind (`i in [1,2,3,4]`).\n",
      "--- quadType ---\n",
      "Quadrature type used for the points in [0, 1]:\n",
      "- `LOBATTO` : 0 and 1 are included\n",
      "- `GAUSS` : neither 0 nor 1 are included\n",
      "- `RADAU-RIGHT` : only 1 is included\n",
      "- `RADAU-LEFT` : only 0 is included\n",
      "--- form ---\n",
      "Used formulation, can be either :\n",
      "- `Z2N` : zeros-to-nodes formulation, i.e the `chi` operator produces\n",
      "a vector of the form :math:`[u_0, u_0, ..., u_0]` and `phi` represents\n",
      "the integration from :math:`u_{0}` to each block time points (nodes).\n",
      "- `N2N` : node-to-node formulation, i.e the `chi` operator produces\n",
      "a vector of the form :math:`[u_0, 0, ..., 0]` and `phi` represents\n",
      "the integration from one time point (node) to the next one.\n",
      "--- collUpdate ---\n",
      "Wether to use or not the collocation update at the end of the step.\n"
     ]
    }
   ],
   "source": [
    "for param, doc in SCHEMES['Collocation'].getParamsDocs().items():\n",
    "    print(f'--- {param} ---')\n",
    "    print(doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a57b47b",
   "metadata": {},
   "source": [
    "## Instantiation and use of a `BlockScheme` subclass\n",
    "\n",
    "Once the user is set on a type of time-stepping method, the next step is to instantiate the corresponding `BlockScheme` subclass and use its `getBlockOperators(...)` method to generate the corresponding `BlockOperator` for one given value of $\\lambda\\Delta{T}$.\n",
    "\n",
    "For instance, let us choose the `RungeKutta` time-stepping type, and look at the different parameters that have to be set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "513a761e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.122405Z",
     "iopub.status.busy": "2023-03-28T16:13:52.121888Z",
     "iopub.status.idle": "2023-03-28T16:13:52.128368Z",
     "shell.execute_reply": "2023-03-28T16:13:52.127534Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nPoints': PositiveInteger(default=None),\n",
       " 'ptsType': MultipleChoices(default=EQUID),\n",
       " 'quadType': MultipleChoices(default=LOBATTO),\n",
       " 'form': MultipleChoices(default=Z2N),\n",
       " 'rkScheme': MultipleChoices(default=BE),\n",
       " 'nStepsPerPoint': PositiveInteger(default=1)}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BlockSchemeClass = SCHEMES['RungeKutta']\n",
    "BlockSchemeClass.PARAMS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ab9c42b",
   "metadata": {},
   "source": [
    "Here only the number of points `nPoints` is non optional, which means that we can instantiate the `BlockScheme` subclass with 5 time points, for instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "78dec50a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.133812Z",
     "iopub.status.busy": "2023-03-28T16:13:52.133012Z",
     "iopub.status.idle": "2023-03-28T16:13:52.140582Z",
     "shell.execute_reply": "2023-03-28T16:13:52.139718Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nPoints': PositiveInteger(value=5),\n",
       " 'ptsType': MultipleChoices(value=EQUID),\n",
       " 'quadType': MultipleChoices(value=LOBATTO),\n",
       " 'form': MultipleChoices(value=Z2N),\n",
       " 'rkScheme': MultipleChoices(value=BE),\n",
       " 'nStepsPerPoint': PositiveInteger(value=1)}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rkScheme = BlockSchemeClass(5)\n",
    "rkScheme.PARAMS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cfa33f0",
   "metadata": {},
   "source": [
    "We see now that the `PARAMS` displays parameters with their type and value (no default anymore), since the class has been instantiated and parameters values have been given.\n",
    "\n",
    "Additionally, parameters values are accessible through a dictionary returned by the instance method `getParamsValue`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6478b55e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.145272Z",
     "iopub.status.busy": "2023-03-28T16:13:52.144761Z",
     "iopub.status.idle": "2023-03-28T16:13:52.152722Z",
     "shell.execute_reply": "2023-03-28T16:13:52.151868Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nPoints': 5,\n",
       " 'ptsType': 'EQUID',\n",
       " 'quadType': 'LOBATTO',\n",
       " 'form': 'Z2N',\n",
       " 'rkScheme': 'BE',\n",
       " 'nStepsPerPoint': 1}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rkScheme.getParamsValue()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0255956d",
   "metadata": {},
   "source": [
    "Also, the normalized time point coordinates for the block are available through the `points` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ef734070",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.157758Z",
     "iopub.status.busy": "2023-03-28T16:13:52.157266Z",
     "iopub.status.idle": "2023-03-28T16:13:52.163511Z",
     "shell.execute_reply": "2023-03-28T16:13:52.162692Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rkScheme.points"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ff2c44d",
   "metadata": {},
   "source": [
    "One can also change the parameters, provided that those are accepted by the parameter class. For instance, if we want to change the `rkScheme` parameter to `EI` (method that does not exists):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "465948b2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.169095Z",
     "iopub.status.busy": "2023-03-28T16:13:52.168613Z",
     "iopub.status.idle": "2023-03-28T16:13:52.175478Z",
     "shell.execute_reply": "2023-03-28T16:13:52.174615Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ParamError : rkScheme=EI -> is not in ['BE', 'FE', 'RK21', 'TRAP', 'RK2', 'GAUSS-LG', 'SDIRK2', 'RK3', 'RK53', 'SDIRK3', 'RK4', 'SDIRK54', 'RK65', 'EXACT'] (MultipleChoices)\n",
      " -- name : rkScheme\n",
      " -- value : EI\n",
      " -- reason : is not in ['BE', 'FE', 'RK21', 'TRAP', 'RK2', 'GAUSS-LG', 'SDIRK2', 'RK3', 'RK53', 'SDIRK3', 'RK4', 'SDIRK54', 'RK65', 'EXACT'] (MultipleChoices)\n"
     ]
    }
   ],
   "source": [
    "from blockops.utils.params import ParamError\n",
    "\n",
    "try:\n",
    "    rkScheme = BlockSchemeClass(5, rkScheme='EI')\n",
    "except ParamError as err:\n",
    "    print(f'ParamError : {err.msg}')\n",
    "    print(f' -- name : {err.name}')\n",
    "    print(f' -- value : {err.value}')\n",
    "    print(f' -- reason : {err.reason}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ae71b3",
   "metadata": {},
   "source": [
    "We see in the raised exception that the parameter value is not accepted, and indication are done on how to solve it.\n",
    "\n",
    "Same goes for the `ptsType` parameter, for which we can provide either a string or a list of float values with predefined points. If the later are wrongly provided, we can see the reason why in the exception message :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0e1028f2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-28T16:13:52.181549Z",
     "iopub.status.busy": "2023-03-28T16:13:52.181049Z",
     "iopub.status.idle": "2023-03-28T16:13:52.188051Z",
     "shell.execute_reply": "2023-03-28T16:13:52.187178Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ParamError : ptsType=[-1, 0, 1] -> is not in ['EQUID', 'LEGENDRE', 'CHEBY-1', 'CHEBY-2', 'CHEBY-3', 'CHEBY-4'] (MultipleChoices)\n",
      " -- name : ptsType\n",
      " -- value : [-1, 0, 1]\n",
      " -- reason : is not in ['EQUID', 'LEGENDRE', 'CHEBY-1', 'CHEBY-2', 'CHEBY-3', 'CHEBY-4'] (MultipleChoices)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    rkScheme = BlockSchemeClass(5, ptsType=[-1, 0, 1])\n",
    "except ParamError as err:\n",
    "    print(f'ParamError : {err.msg}')\n",
    "    print(f' -- name : {err.name}')\n",
    "    print(f' -- value : {err.value}')\n",
    "    print(f' -- reason : {err.reason}')"
   ]
  }
 ],
 "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.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}