Repository: qutech/qopt (language: python)

Issue:
Added mpl cmap to plot_energy_spectrum
Added a dynamic method for obtaining colours for `plot_energy_spectrum` using mpl cmaps. 
With this, energy spectra of Hamiltonians with multiple dimensions can be plotted.

![image](https://user-images.githubusercontent.com/9484174/157465524-0c51f021-88da-4f63-97d5-cc31fd90cbb6.png)



Discussion / hints:

Fix patch:
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
new file mode 100644
index 0000000..e17554e
--- /dev/null
+++ b/.github/workflows/python-publish.yml
@@ -0,0 +1,28 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        ref: release
+    - name: Set up Python
+      uses: actions/setup-python@v1
+      with:
+        python-version: '3.7'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      run: |
+        python setup.py sdist bdist_wheel
+        twine upload dist/*
diff --git a/doc/source/examples/examples.rst b/doc/source/examples/examples.rst
index 1d4f4cf..bc16788 100644
--- a/doc/source/examples/examples.rst
+++ b/doc/source/examples/examples.rst
@@ -12,3 +12,4 @@ from *Doc/source/examples* using `jupyter notebook`.
    t2_markovian_noise
    t2_non_markovian_noise
    consistency_test
+   phase_noise
diff --git a/doc/source/examples/phase_noise.ipynb b/doc/source/examples/phase_noise.ipynb
new file mode 100644
index 0000000..4401dd5
--- /dev/null
+++ b/doc/source/examples/phase_noise.ipynb
@@ -0,0 +1,698 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Phase Noise with Filter Functions\n",
+    "\n",
+    "In this section we discuss how to use filter functions to study the effect\n",
+    "of amplitude, frequency and also phase noise on a resonantly driven qubit.\n",
+    "We start by discussing the coherent dynamics and then add filter function.\n",
+    "\n",
+    "## Coherent Dynamics\n",
+    "We consider a single qubit with a resonant drive source. The Hamiltonian in\n",
+    "the lab frame is given as:\n",
+    "\n",
+    "\\begin{align}\n",
+    "H_L = \\omega_0 \\sigma_z + A(t) \\cos(\\omega t + \\phi(t)),\n",
+    "\\end{align}\n",
+    "\n",
+    "where $\\omega_0$ is the resonance frequency of the qubit, $A(t)$ is the\n",
+    "time-depended driving amplitude, $\\omega$ is the driving frequency and\n",
+    "$\\phi(t)$ is the time-depended phase of the driving signal. We transform the\n",
+    "Hamiltonian into the rotating frame and apply the rotating wave approximation\n",
+    "to yield:\n",
+    "\n",
+    "\\begin{align}\n",
+    "    H = (\\omega - \\omega_0) \\sigma_z + A(t) (\\cos(\\phi(t)) \\sigma_x + \\sin(\\phi(t)) \\sigma_y).\n",
+    "\\end{align}\n",
+    "\n",
+    "We assume resonant control $\\omega - \\omega_0 = 0$. To bring the Hamiltonian\n",
+    "into the standard form $H_c = \\sum_k u_k C_k$ we identify:\n",
+    "\n",
+    "\\begin{align}\n",
+    "u_1 &= A(t)\\cos(\\phi(t)) \\\\\n",
+    "u_2 &= A(t)\\sin(\\phi(t)) \\\\\n",
+    "C_1 &= \\sigma_x \\\\\n",
+    "C_2 &= \\sigma_y\n",
+    "\\end{align}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from qopt import *\n",
+    "import numpy as np\n",
+    "import filter_functions as ff\n",
+    "\n",
+    "n_time_steps = 10\n",
+    "delta_t = 1\n",
+    "\n",
+    "\n",
+    "h_ctrl = [DenseOperator.pauli_x(), DenseOperator.pauli_y()]\n",
+    "\n",
+    "def amplitudes(opt_pars):\n",
+    "    # This amplitude function does not need to alter the shape of the input.\n",
+    "    ctrl_amplitudes = np.empty_like(opt_pars)\n",
+    "\n",
+    "    # x-control\n",
+    "    ctrl_amplitudes[:, 0] = opt_pars[:, 0] * np.cos(opt_pars[:, 1])\n",
+    "\n",
+    "    # y-control\n",
+    "    ctrl_amplitudes[:, 1] = opt_pars[:, 0] * np.sin(opt_pars[:, 1])\n",
+    "    return ctrl_amplitudes"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "To use analytical gradients, we also need the derivatives of our control\n",
+    "amplitudes by the optimization parameters $v_1(t) = A(t)$ and $v_2(t)=\\phi(t)$:\n",
+    "\n",
+    "\\begin{align}\n",
+    "\\frac{\\partial \\vec{u}}{\\partial \\vec{v}} =\n",
+    "\\begin{pmatrix}\n",
+    "\\frac{\\partial u_1}{\\partial v_1} & \\frac{\\partial u_1}{\\partial v_2} \\\\\n",
+    "\\frac{\\partial u_2}{\\partial v_1} & \\frac{\\partial u_2}{\\partial v_2} \\\\\n",
+    "\\end{pmatrix} =\n",
+    "\\begin{pmatrix}\n",
+    "\\cos(\\phi(t)) & -A(t)\\sin(\\phi(t)) \\\\\n",
+    "\\sin(\\phi(t)) & A(t)\\cos(\\phi(t)) \\\\\n",
+    "\\end{pmatrix}\n",
+    "\\end{align}"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "outputs": [],
+   "source": [
+    "def amplitude_derivatives(opt_pars):\n",
+    "    derivatives = np.empty(shape=([n_time_steps, 2, 2]), dtype=float)\n",
+    "\n",
+    "    # derivatives by the amplitude\n",
+    "    derivatives[:, 0, 0] = np.cos(opt_pars[:, 1])\n",
+    "    derivatives[:, 0, 1] = np.sin(opt_pars[:, 1])\n",
+    "\n",
+    "    # derivatives by the phase\n",
+    "    derivatives[:, 1, 0] = -1 * opt_pars[:, 0] * np.sin(opt_pars[:, 1])\n",
+    "    derivatives[:, 1, 1] = opt_pars[:, 0] * np.cos(opt_pars[:, 1])\n",
+    "\n",
+    "    return derivatives\n",
+    "\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Noisy Dynamics\n",
+    "\n",
+    "We want to consider noise on the amplitude $A \\rightarrow A + \\delta A$,\n",
+    "frequency $\\omega \\rightarrow \\omega + \\delta \\omega$\n",
+    "and on the phase $\\phi \\rightarrow \\phi + \\delta \\phi$.\n",
+    "To bring the Hamiltonian into the form $H = H_c + H_n$ with seperated control\n",
+    "Hamiltonian $H_c$ and noise Hamiltonian $H_n$, we perform a Taylor-Expansion\n",
+    "and neglect terms beyond the first order.\n",
+    "\n",
+    "\\begin{align}\n",
+    "    H &= (\\omega(t) + \\delta \\omega(t) - \\omega_0) \\sigma_z + [A(t) + \\delta A(t)]\n",
+    "    (\\cos(\\phi(t) + \\delta \\phi(t)) \\sigma_x + \\sin(\\phi(t) + \\delta \\phi(t)) \\sigma_y) \\\\\n",
+    "    &\\approx A(t) (\\cos(\\phi(t)) \\sigma_x + \\sin(\\phi(t)) \\sigma_y) \\\\\n",
+    "    &+ \\delta A(t) (\\cos(\\phi(t)) \\sigma_x + \\sin(\\phi(t)) \\sigma_y)\\\\\n",
+    "    & + \\delta \\phi A(t) (-\\sin(\\phi(t)) \\sigma_x + cos(\\phi(t)) \\sigma_y) \\\\\n",
+    "    & + \\delta \\omega \\sigma_z.\n",
+    "\\end{align}\n",
+    "\n",
+    "Please note that $\\delta \\omega$ can equally be used to describe noise on the\n",
+    "resonant frequency of the qubit or the frequency of the driving system.\n",
+    "\n",
+    "Harrison Ball\n",
+    "*et al.* applied a first order approximation to the phase noise\n",
+    "$\\phi(t) \\approx \\dot{\\phi}t$, such they could regard it as  additional\n",
+    "perturbation to the driving frequency in\n",
+    "[https://doi.org/10.1038/npjqi.2016.33](https://doi.org/10.1038/npjqi.2016.33).\n",
+    "Here we want to keep the full phase noise dynamics.\n",
+    "\n",
+    "We need to bring the noise Hamiltonian into the form\n",
+    "\n",
+    "\\begin{equation}\n",
+    "H_n=\\sum_k s_k b_k B_k\n",
+    "\\end{equation}\n",
+    "\n",
+    "and thus we identify:\n",
+    "\n",
+    "\\begin{align}\n",
+    "b_1(t) &= b_2(t) = \\delta A(t) \\\\\n",
+    "b_3(t) &= b_4(t) = \\delta \\phi(t) \\\\\n",
+    "b_5(t) &= \\delta \\omega(t) \\\\\n",
+    "s_1(t) &= \\cos(\\phi(t)) = \\frac{\\partial u_1}{\\partial v_1} \\\\\n",
+    "s_2(t) &= \\sin(\\phi(t)) = \\frac{\\partial u_2}{\\partial v_1} \\\\\n",
+    "s_3(t) &= -A(t) \\sin(\\phi(t)) = \\frac{\\partial u_1}{\\partial v_2} \\\\\n",
+    "s_4(t) &= A(t) cos(\\phi(t)) = \\frac{\\partial u_2}{\\partial v_2} \\\\\n",
+    "s_5(t) &= 1 \\\\\n",
+    "B_1 &= B_3 = \\sigma_x \\\\\n",
+    "B_2 &= B_4 = \\sigma_y \\\\\n",
+    "B_5 &= \\sigma_z\n",
+    "\\end{align}\n",
+    "\n",
+    "In the implementation of the noise Hamiltonian for the filter functions,\n",
+    "we can reuse the derivatives from the amplitude function:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "outputs": [],
+   "source": [
+    "def filter_function_h_n(opt_pars, tr_pars, ctrl_amps):\n",
+    "    deriv_ctrl_amps_by_opt_pars = amplitude_derivatives(opt_pars)\n",
+    "\n",
+    "    return [[\n",
+    "    .5 * DenseOperator.pauli_x(),\n",
+    "    deriv_ctrl_amps_by_opt_pars[:, 0, 0],\n",
+    "    'Amplitude Noise 1'\n",
+    "],\n",
+    "[\n",
+    "    .5 * DenseOperator.pauli_y(),\n",
+    "    deriv_ctrl_amps_by_opt_pars[:, 0, 1],\n",
+    "    'Amplitude Noise 2'\n",
+    "],\n",
+    "[\n",
+    "    .5 * DenseOperator.pauli_x(),\n",
+    "    deriv_ctrl_amps_by_opt_pars[:, 1, 0],\n",
+    "    'Phase Noise 1'\n",
+    "],\n",
+    "[\n",
+    "    .5 * DenseOperator.pauli_y(),\n",
+    "    deriv_ctrl_amps_by_opt_pars[:, 1, 1],\n",
+    "    'Phase Noise 2'\n",
+    "],\n",
+    "[\n",
+    "    .5 * DenseOperator.pauli_z(),\n",
+    "    np.ones(n_time_steps),\n",
+    "    'Z Frequency Noise'\n",
+    "],\n",
+    "]"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Next, we need the derivatives of the noise susceptibilities by the control\n",
+    "amplitudes. And employ the chain rule for this purpose:\n",
+    "\n",
+    "\\begin{align}\n",
+    "\\frac{\\partial \\vec{s}}{\\partial \\vec{u}}\n",
+    "= \\frac{\\partial \\vec{s}}{\\partial \\vec{v}}\n",
+    "\\frac{\\partial \\vec{v}}{\\partial \\vec{u}}\n",
+    "= \\frac{\\partial \\vec{s}}{\\partial \\vec{v}}\n",
+    "\\left(\\frac{\\partial \\vec{u}}{\\partial \\vec{v}} \\right)^{-1}\n",
+    "\\end{align}\n",
+    "\n",
+    "with\n",
+    "\n",
+    "\\begin{align}\n",
+    "\\frac{\\partial \\vec{s}}{\\partial \\vec{v}} =\n",
+    "\\begin{pmatrix}\n",
+    "\\frac{\\partial s_1}{\\partial v_1} & \\frac{\\partial s_1}{\\partial v_2} \\\\\n",
+    "\\frac{\\partial s_2}{\\partial v_1} & \\frac{\\partial s_2}{\\partial v_2} \\\\\n",
+    "\\frac{\\partial s_3}{\\partial v_1} & \\frac{\\partial s_3}{\\partial v_2} \\\\\n",
+    "\\frac{\\partial s_4}{\\partial v_1} & \\frac{\\partial s_4}{\\partial v_2} \\\\\n",
+    "\\frac{\\partial s_54}{\\partial v_1} & \\frac{\\partial s_5}{\\partial v_2} \\\\\n",
+    "\\end{pmatrix}\n",
+    "=\n",
+    "\\begin{pmatrix}\n",
+    "\\frac{\\partial \\cos(\\phi(t))}{\\partial A} & \\frac{\\partial \\cos(\\phi(t))}{\\partial \\phi} \\\\\n",
+    "\\frac{\\partial \\sin(\\phi(t))}{\\partial A} & \\frac{\\partial \\sin(\\phi(t))}{\\partial \\phi} \\\\\n",
+    "\\frac{ -\\partial A(t)\\sin(\\phi(t))}{\\partial A} & \\frac{ -\\partial A(t)\\sin(\\phi(t))}{\\partial \\phi} \\\\\n",
+    "\\frac{\\partial A(t)\\cos(\\phi(t))}{\\partial A} & \\frac{\\partial A(t)\\cos(\\phi(t))}{\\partial \\phi} \\\\\n",
+    "\\frac{\\partial 1}{\\partial A} & \\frac{\\partial 1}{\\partial \\phi} \\\\\n",
+    "\\end{pmatrix}\n",
+    "=\n",
+    "\\begin{pmatrix}\n",
+    "0 & -\\sin(\\phi(t)) \\\\\n",
+    "0 & \\cos(\\phi(t)) \\\\\n",
+    " -\\sin(\\phi(t)) &  -A(t)\\cos(\\phi(t)) \\\\\n",
+    "\\cos(\\phi(t)) & - A(t)\\sin(\\phi(t)) \\\\\n",
+    "0 & 0 \\\\\n",
+    "\\end{pmatrix}\n",
+    "\\end{align}\n",
+    "."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "def filter_function_n_coeffs_deriv(opt_pars, tr_pars, ctrl_amps):\n",
+    "    # start with the derivatives of the noise susceptibilities by the\n",
+    "    # optimizaiton parameters\n",
+    "    deriv_susceptibilities_by_opt_pars = np.zeros(\n",
+    "        shape=[opt_pars.shape[0], 5, 2], dtype=float)\n",
+    "\n",
+    "    # derivatives by the Amplitude\n",
+    "    deriv_susceptibilities_by_opt_pars[:, 2, 0] = -1 * np.sin(opt_pars[:, 1])\n",
+    "    deriv_susceptibilities_by_opt_pars[:, 3, 0] = np.cos(opt_pars[:, 1])\n",
+    "\n",
+    "    # derivatives by the phase\n",
+    "    deriv_susceptibilities_by_opt_pars[:, 0, 1] = \\\n",
+    "        deriv_susceptibilities_by_opt_pars[:, 2, 0]\n",
+    "    deriv_susceptibilities_by_opt_pars[:, 1, 1] = \\\n",
+    "        deriv_susceptibilities_by_opt_pars[:, 3, 0]\n",
+    "    deriv_susceptibilities_by_opt_pars[:, 2, 1] = \\\n",
+    "        -1 * opt_pars[:, 0] *  np.cos(opt_pars[:, 1])\n",
+    "    deriv_susceptibilities_by_opt_pars[:, 3, 1] = \\\n",
+    "        -1 * opt_pars[:, 0] *  np.sin(opt_pars[:, 1])\n",
+    "\n",
+    "    # Then we calculate the derivatives of the optimization parameters by the\n",
+    "    # control amplitudes,\n",
+    "\n",
+    "    # by first calculating the partial derivatives of the control amplitudes\n",
+    "    # by the optimizaiton parameters:\n",
+    "    deriv_ctrl_amps_by_opt_pars = amplitude_derivatives(opt_pars)\n",
+    "\n",
+    "    # we transpose to yield the shape(n_time, n_ctrl_amps, n_opt_pars)\n",
+    "    deriv_ctrl_amps_by_opt_pars = np.transpose(deriv_ctrl_amps_by_opt_pars,\n",
+    "        axes=[0, 2, 1])\n",
+    "\n",
+    "    # and then calculating the inverse.\n",
+    "    deriv_opt_pars_by_ctrl_amps = np.linalg.inv(deriv_ctrl_amps_by_opt_pars)\n",
+    "\n",
+    "    # finally we can calculate the desired derivatives\n",
+    "    deriv_susceptibilities_by_ctrl_amps = np.einsum(\n",
+    "        'tsv,tvu->sut',\n",
+    "        deriv_susceptibilities_by_opt_pars,\n",
+    "        deriv_opt_pars_by_ctrl_amps\n",
+    "    )\n",
+    "    # the final shape is chosen as required by the filter_functions_package\n",
+    "    return deriv_susceptibilities_by_ctrl_amps"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "execution_count": 65,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Next we can put everything together to create the solver:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "outputs": [],
+   "source": [
+    "amplitude_function = CustomAmpFunc(\n",
+    "    value_function=amplitudes,\n",
+    "    derivative_function=amplitude_derivatives\n",
+    ")\n",
+    "\n",
+    "solver = SchroedingerSolver(\n",
+    "    h_drift=[0 * DenseOperator.pauli_x()],\n",
+    "    h_ctrl=h_ctrl,\n",
+    "    tau=delta_t*np.ones(n_time_steps),\n",
+    "    amplitude_function=amplitude_function,\n",
+    "    filter_function_h_n=filter_function_h_n,\n",
+    "    filter_function_n_coeffs_deriv=filter_function_n_coeffs_deriv\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "We can check the implementation of the coherent dynamics with a simple pulse:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 360x360 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "x_pi_half_gate_pulse = np.zeros(shape=(n_time_steps, 2), dtype=float)\n",
+    "x_pi_half_gate_pulse[:, 0] = .25 * np.pi / (n_time_steps * delta_t)\n",
+    "x_pi_half_gate_pulse[:, 1] = .5 * np.pi\n",
+    "solver.set_optimization_parameters(x_pi_half_gate_pulse)\n",
+    "solver.plot_bloch_sphere()\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "To get interesting filter functions, we generate a random pulse:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "np.random.seed(4)\n",
+    "random_pulse = np.zeros(shape=(n_time_steps, 2), dtype=float)\n",
+    "random_pulse[:, 0] = np.random.rand(n_time_steps) * np.pi / (n_time_steps * delta_t)\n",
+    "random_pulse[:, 1] = 1 * np.random.rand(n_time_steps) * np.pi\n",
+    "\n",
+    "solver.create_pulse_sequence(random_pulse)\n",
+    "pulse_sequence = solver.pulse_sequence\n",
+    "omega = ff.util.get_sample_frequencies(\n",
+    "    pulse_sequence, n_samples=200, spacing='log')\n",
+    "_ = ff.plotting.plot_filter_function(pulse_sequence, omega, yscale='log')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Now we define a noise spectral density. In our model, we assume that the\n",
+    "amplitude is subjected to $1/f$ type noise, the phase is subjected to white noise\n",
+    "and the frequency is subjected to $1/f^2$ noise.\n",
+    "\n",
+    "We verify that everything is set up correctly by calculating the cost functions\n",
+    "and compare the analytic to numeric derivatives calculated by finite\n",
+    "differences."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Infidelities calculated with filter function:\n",
+      "[0.81526447 0.00651779 0.02648523 0.00099263 0.00440001 0.04920558]\n",
+      "Absolute and relative deviation of analytic and numeric gradients.\n",
+      "(3.67134370062733e-08, 1.994717060668004e-08)\n"
+     ]
+    }
+   ],
+   "source": [
+    "def psd(f):\n",
+    "    spectral_power_density = np.zeros(shape=[5, f.shape[0]], dtype=float)\n",
+    "    # 1/f noise on the amplitudes\n",
+    "    spectral_power_density[0, :] = .01 / f\n",
+    "    spectral_power_density[1, :] = .01 / f\n",
+    "    # white noise on the phase\n",
+    "    spectral_power_density[2, :] = .1\n",
+    "    spectral_power_density[3, :] = .1\n",
+    "    # 1/f^2 noise on the frequency\n",
+    "    spectral_power_density[4, :] = .0001 / f ** 2\n",
+    "    return spectral_power_density\n",
+    "\n",
+    "ff_infidelity = OperatorFilterFunctionInfidelity(\n",
+    "    solver=solver,\n",
+    "    noise_power_spec_density=psd,\n",
+    "    omega=omega\n",
+    ")\n",
+    "\n",
+    "target_gate = DenseOperator.pauli_x().exp(-1j * .25 * np.pi)\n",
+    "coherent_infid = OperationInfidelity(\n",
+    "    solver=solver,\n",
+    "    target=target_gate\n",
+    ")\n",
+    "\n",
+    "simulator = Simulator(\n",
+    "    solvers=[solver, ],\n",
+    "    cost_funcs=[coherent_infid, ff_infidelity]\n",
+    ")\n",
+    "print('Infidelities calculated with filter function:')\n",
+    "print(simulator.wrapped_cost_functions(random_pulse))\n",
+    "print('Absolute and relative deviation of analytic and numeric gradients.')\n",
+    "print(simulator.compare_numeric_to_analytic_gradient(random_pulse))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In a last step, we can start an optimization. We set the cost_func_weights\n",
+    "to give the infidelitites calculated with the filter functions a higher weight\n",
+    "of two orders of magnitude. This is sometimes necessary to avoid, that the\n",
+    "optimizer simply optimizes the coherent dynamics and then gets stuck in a local\n",
+    "optimum."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<AxesSubplot:xlabel='Iteration', ylabel='Costs'>"
+     },
+     "execution_count": 70,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizer = ScalarMinimizingOptimizer(\n",
+    "    system_simulator=simulator,\n",
+    "    cost_func_weights=[1, 1e2, 1e2, 1e2, 1e2, 1e2]\n",
+    ")\n",
+    "\n",
+    "result = optimizer.run_optimization(random_pulse)\n",
+    "\n",
+    "data_container = DataContainer()\n",
+    "data_container.append_optim_result(result)\n",
+    "analyser = Analyser(data_container)\n",
+    "analyser.plot_costs()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In a last step, we restart the optimization without weights to calibrate\n",
+    "coherent errors. As initial pulse, we use the optimized pulse from the last\n",
+    "optimization."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 360x360 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizer.cost_func_weights = None\n",
+    "result_2 = optimizer.run_optimization(result.final_parameters)\n",
+    "data_container.append_optim_result(result_2)\n",
+    "analyser.plot_costs(n=1)\n",
+    "\n",
+    "solver.plot_bloch_sphere(result_2.final_parameters)\n",
+    "solver.create_pulse_sequence(result_2.final_parameters)\n",
+    "pulse_sequence = solver.pulse_sequence\n",
+    "_ = ff.plotting.plot_filter_function(pulse_sequence, omega, yscale='log')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/doc/source/qopt_features/filter_functions_basic.ipynb b/doc/source/qopt_features/filter_functions_basic.ipynb
new file mode 100644
index 0000000..4c0d511
--- /dev/null
+++ b/doc/source/qopt_features/filter_functions_basic.ipynb
@@ -0,0 +1,565 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Filter Functions\n",
+    "\n",
+    "are a great mathematical tool to calculate the influence of classical noise\n",
+    "with a\n",
+    "given spectral noise density on a quantum gate. Especially for small systems\n",
+    "and high noise frequencies,\n",
+    "the simulation with filter functions is much more efficient than a Monte Carlo\n",
+    "simulation and more general than a Lindblad master equation.\n",
+    "\n",
+    "The implementation of filter functions is imported from the package\n",
+    "`filter_functions`\n",
+    "[available on github](https://github.com/qutech/filter_functions). You can find\n",
+    "additional literature on filter functions in the following papers.\n",
+    "\n",
+    "Tobias Hangleiter, P. Cerfontaine, and H. Bluhm. Filter-function formalism and\n",
+    "software package to compute quantum processes of gate sequences for classical\n",
+    "non-Markovian noise. Phys. Rev. Res. **3**, 043047 (2021).\n",
+    "[10.1103/PhysRevResearch.3.043047](https://doi.org/10.1103/PhysRevResearch.3.043047).\n",
+    "[arXiv:2103.02403](https://arxiv.org/abs/2103.02403).\n",
+    "\n",
+    "Pascal Cerfontaine, T. Hangleiter, and H. Bluhm. Filter Functions for Quantum\n",
+    "Processes under Correlated Noise. Phys. Rev. Lett. **127**, 170403 (2021).\n",
+    "[10.1103/PhysRevLett.127.170403](https://doi.org/10.1103/PhysRevLett.127.170403).\n",
+    "[arXiv:2103.02385](https://arxiv.org/abs/2103.02385).\n",
+    "\n",
+    "\n",
+    "## Example System\n",
+    "\n",
+    "Lets consider the example of a singlet-triplet qubit. In this encoding of a\n",
+    "semiconductor spin qubit, two electrons are confined in a double quantum dot\n",
+    "subjected to a magnetic field. The computational states are the spin states of\n",
+    "zero total spin along the quantization axis $\\vert \\uparrow \\downarrow>$ and\n",
+    "$\\vert \\downarrow \\uparrow>$. The Hamiltonian consists is then written as\n",
+    "\n",
+    "\\begin{equation}\n",
+    "H=\\Delta B_z \\sigma_z + J(\\epsilon(t))\\sigma_x\n",
+    "\\end{equation}\n",
+    "\n",
+    "with the magnetic field gradient $\\Delta B_z$ across the double quantum dot and\n",
+    "the exchange interaction $J(\\epsilon(t)) = e^{\\epsilon(t)}$ depending on the difference in\n",
+    "chemical potential $\\epsilon(t)$. This potential $\\epsilon$ is electrically\n",
+    "controlled to drive qubit rotations while the magnetic gradient establishes the\n",
+    "drift dynamics, and we identify the drift Hamiltonian\n",
+    "$H_d = \\Delta B_z \\sigma_z$ and the control Hamiltonian\n",
+    "$H_c = \\sum_k u_k(t) A_k = J(\\epsilon(t))\\sigma_x$ with the only control amplitude\n",
+    "$u_1 = J(\\epsilon(t))$ depending on the optimization parameter $v=\\epsilon$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "outputs": [],
+   "source": [
+    "from qopt import *\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import filter_functions as ff\n",
+    "\n",
+    "delta_b_z = 2\n",
+    "\n",
+    "n_time_steps = 50\n",
+    "delta_t = .2\n",
+    "\n",
+    "def exchange_energy(epsilon):\n",
+    "    return np.exp(epsilon)\n",
+    "\n",
+    "def deriv_exchange_energy(epsilon):\n",
+    "    return np.exp(epsilon)\n",
+    "\n",
+    "amplitude_function = UnaryAnalyticAmpFunc(\n",
+    "    value_function=exchange_energy,\n",
+    "    derivative_function=deriv_exchange_energy\n",
+    ")\n",
+    "\n",
+    "h_drift = [.5 * delta_b_z * DenseOperator.pauli_z()]\n",
+    "h_ctrl = [.5 * DenseOperator.pauli_x()]\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Calculate Filter Functions\n",
+    "\n",
+    "We will now discuss how to calculate filter function with the qopt interface.\n",
+    "\n",
+    "Any noise on the electrical control $\\epsilon(t)\n",
+    "\\rightarrow \\epsilon(t) + \\delta \\epsilon(t)$ couples to the qubit via the\n",
+    "noise hamiltonian\n",
+    "\n",
+    "\\begin{equation}\n",
+    "H_n= \\delta \\epsilon(t) \\frac{\\partial J(\\epsilon(t))}{\\partial \\epsilon}\\sigma_x.\n",
+    "\\end{equation}\n",
+    "\n",
+    "The argument `filter_function_h_n` contains the noise Hamiltonian which must be\n",
+    "of the form\n",
+    "\n",
+    "\\begin{equation}\n",
+    "H_n=\\sum_k s_k b_k B_k.\n",
+    "\\end{equation}\n",
+    "\n",
+    "where $s_k$ is the noise susceptibility, $b_k$ is the noise amplitude and\n",
+    "$B_k$ the operator coupling to the system. In this example we just have a\n",
+    "single term with $s=\\frac{\\partial J(\\epsilon(t))}{\\partial \\epsilon}$,\n",
+    "$b=\\delta \\epsilon$ and $B=\\sigma_x$.\n",
+    "\n",
+    "The argument `filter_function_h_n` must be given as callable in this example,\n",
+    "because depends on the control amplitudes and is not constant. It is given\n",
+    "as function receiving three arguments:\n",
+    "1. Optimization Parameters: The parameters that are set to the solver.\n",
+    "2. Transferred Parameters: These are the optimization parameters after the\n",
+    "transfer function has been applied. (See also the section about transfer\n",
+    "functions.)\n",
+    "3. Control Amplitudes: These are calculated by applying the transfer function\n",
+    "and the amplitude function. (See also the section about the amplitude\n",
+    "function.)\n",
+    "\n",
+    "In this example, we do not use a transfer function and hence the first two\n",
+    "arguments are equal."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "outputs": [],
+   "source": [
+    "# The filter function noise Hamiltonian can also be set statically, if it does\n",
+    "# not depend on the control amplitudes.\n",
+    "def filter_function_h_n(opt_pars, tr_pars, ctrl_amps):\n",
+    "    return [[\n",
+    "    .5 * DenseOperator.pauli_z(),\n",
+    "    deriv_exchange_energy(opt_pars)[:, 0],\n",
+    "    'Electric Noise'\n",
+    "]]"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In the next section, we also want to use the filter functions for optimal\n",
+    "control and with analytic\n",
+    "gradients, and the calculation of the derivative of the filter function needs\n",
+    "the derivative of the noise susceptibility\n",
+    "$s=\\frac{\\partial J(\\epsilon(t))}{\\partial \\epsilon}=\\frac{\\partial e^{\n",
+    "\\epsilon(t)}}{\\partial \\epsilon} = e^{\\epsilon(t)} = J$ by the control\n",
+    "amplitudes, which is\n",
+    "$\\frac{\\partial s}{\\partial u}=\\frac{\\partial J(\\epsilon(t))}{\\partial J(\\epsilon(t))}=1$.\n",
+    "It might feel unintuitive that we need the derivative by the control amplitudes\n",
+    "$\\frac{\\partial s}{\\partial u}$\n",
+    "and not directly by the optimization parameter\n",
+    "$\\frac{\\partial x}{\\partial v}$, but this is required by the structure of qopt,\n",
+    "because qopt first calculates the derivatives of the cost functions by the\n",
+    "control amplitudes and then uses automatically the transfer and the amplitude\n",
+    "function to calculate the derivatives by the optimization parameters.\n",
+    "This information is given to the solver in the argument\n",
+    "`filter_function_n_coeffs_deriv`, which has the same signature as\n",
+    "`filter_function_h_n`.\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "outputs": [],
+   "source": [
+    "def filter_function_n_coeffs_deriv(opt_pars, tr_pars, ctrl_amps):\n",
+    "    derivatives = np.ones_like(opt_pars)\n",
+    "    derivatives = np.expand_dims(derivatives.T, axis=0)  # Additional axis for\n",
+    "    # the number of noise operators\n",
+    "    return derivatives\n",
+    "\n",
+    "solver = SchroedingerSolver(\n",
+    "    h_drift=h_drift,\n",
+    "    h_ctrl=h_ctrl,\n",
+    "    tau=delta_t * np.ones(n_time_steps),\n",
+    "    amplitude_function=amplitude_function,\n",
+    "    filter_function_h_n=filter_function_h_n,\n",
+    "    filter_function_n_coeffs_deriv=filter_function_n_coeffs_deriv\n",
+    ")\n",
+    "np.random.seed(0)\n",
+    "ctrl_amplitudes = np.random.rand(n_time_steps, 1) - .5\n",
+    "solver.set_optimization_parameters(ctrl_amplitudes)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "We can create an instance of the `PulseSequence` class, and use all the\n",
+    "functionalities of the `filter_functions` package:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "solver.create_pulse_sequence()\n",
+    "pulse_sequence = solver.pulse_sequence\n",
+    "omega = ff.util.get_sample_frequencies(\n",
+    "    pulse_sequence, n_samples=200, spacing='log')\n",
+    "_ = ff.plotting.plot_filter_function(pulse_sequence, omega)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "But the calculation of the infidelity is also completely capsulated by the cost\n",
+    "function `OperatorFilterFunctionInfidelity`, which also holds the information\n",
+    "about the power spectral density of our noise souce:\n",
+    "\n",
+    "\\begin{equation}\n",
+    "S(f) = \\int <b(0) b(t)> e^{2 \\pi f t} dt = \\int <\\delta \\epsilon(0) \\delta \\epsilon(t)> e^{2 \\pi f t} dt\n",
+    "\\end{equation}"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "array([0.01301858])"
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def psd(f):\n",
+    "    return 1e-3/f\n",
+    "\n",
+    "ff_infid = OperatorFilterFunctionInfidelity(\n",
+    "    solver=solver,\n",
+    "    noise_power_spec_density=psd,\n",
+    "    omega=omega,\n",
+    "    label=['FF Infidelity', ]\n",
+    ")\n",
+    "ff_infid.costs()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Optimal Control with Filter Functions\n",
+    "\n",
+    "With the implementation of\n",
+    "Analytic Filter-Function Derivatives for Quantum Optimal Control,\n",
+    "filter functions are available as efficient tool in quantum optimal control.\n",
+    "The derivatives allow us to optimize pulses with cost functions defined by\n",
+    "filter functions. This enables the numeric calculations of pulses that are\n",
+    "especially robust towards noise of specific frequencies.\n",
+    "\n",
+    "\n",
+    "Isabel N. M. Le, J. D. Teske, T. Hangleiter, P. Cerfontaine, and Hendrik\n",
+    "Bluhm. Analytic Filter Function Derivatives for Quantum Optimal Control. Phys.\n",
+    "Rev. Applied **17**, 024006 (2022).\n",
+    "[10.1103/PhysRevApplied.17.024006](https://doi.org/10.1103/PhysRevApplied.17.024006).\n",
+    "[arXiv:2103.09126](https://arxiv.org/abs/2103.09126).\n",
+    "\n",
+    "Optimal control with filter functions can also be used in noise spectroscopy\n",
+    "since it is possible to optimize\n",
+    "pulses to be susceptibile to a specific noise frequency.\n",
+    "\n",
+    "We optimize a pulse for the example above:"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "outputs": [],
+   "source": [
+    "# We need to add another cost function to set a target gate for the coherent\n",
+    "# evolution in the absence of noise.\n",
+    "coherent_costs = OperationInfidelity(\n",
+    "    solver=solver,\n",
+    "    target=DenseOperator.pauli_x()\n",
+    ")\n",
+    "\n",
+    "simulator = Simulator(\n",
+    "    solvers=[solver, ],\n",
+    "    cost_funcs=[ff_infid, coherent_costs]\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "It is always a good advice to check the implementation of derivatives by\n",
+    "comparing the analytic to numeric gradients. The Simulator has a convenience\n",
+    "function to calculate the absolute and relative deviation of both:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(5.461379710836878e-08, 1.8217219314791737e-07)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(simulator.compare_numeric_to_analytic_gradient(ctrl_amplitudes))\n",
+    "\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "From the comparison of analytic and numeric gradients, we know that our\n",
+    "implementation is correct. Next we optimize the pulse."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "outputs": [],
+   "source": [
+    "optimizer = ScalarMinimizingOptimizer(\n",
+    "    system_simulator=simulator\n",
+    ")\n",
+    "result = optimizer.run_optimization(ctrl_amplitudes)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Lets plot the results of the optimization:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<AxesSubplot:xlabel='Iteration', ylabel='Costs'>"
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = DataContainer()\n",
+    "data.append_optim_result(result)\n",
+    "analyser = Analyser(data)\n",
+    "analyser.plot_costs()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The Infidelity contribution of the 1/f-noise has dropped substantially. We\n",
+    "plot again the filter function and the pulse."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 360x360 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pulse_sequence2 = solver.create_pulse_sequence(result.final_parameters)\n",
+    "ff.plotting.plot_filter_function(pulse_sequence2, omega)\n",
+    "\n",
+    "solver.plot_bloch_sphere()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/doc/source/qopt_features/operator_class.ipynb b/doc/source/qopt_features/operator_class.ipynb
new file mode 100644
index 0000000..8d8e0f1
--- /dev/null
+++ b/doc/source/qopt_features/operator_class.ipynb
@@ -0,0 +1,416 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Operator Class\n",
+    "\n",
+    "Quantum operators are represented as matrices in qopt. The class `DenseOperator`\n",
+    "encodes a quantum operator in a dense representation. Simple examples are the\n",
+    "pauli matrices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DenseOperator with data: \n",
+      "array([[0.+0.j, 1.+0.j],\n",
+      "       [1.+0.j, 0.+0.j]])\n",
+      "DenseOperator with data: \n",
+      "array([[ 0.+0.j, -0.-1.j],\n",
+      "       [ 0.+1.j,  0.+0.j]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qopt import *\n",
+    "\n",
+    "print(DenseOperator.pauli_x())\n",
+    "print(DenseOperator.pauli_y())\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Internally, the `DenseOperator` is based on a 2-dimensional numpy array, which\n",
+    "can be accessed by the `data` attribute."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n",
+     "is_executing": true
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.+0.j 1.+0.j]\n",
+      " [1.+0.j 0.+0.j]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(DenseOperator.pauli_x().data)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The same class can also be used to store state vectors, density matrices,\n",
+    "propagators and so on. The `DenseOperator` can be initialized from a\n",
+    "2-dimensional numpy array, a scipy sparse matrix or a `Qobj` from the\n",
+    "Quantum Toolbox in Python (QuTiP)."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DenseOperator with data: \n",
+      "array([[ 1.+0.j,  0.+0.j],\n",
+      "       [ 0.+0.j, -1.+0.j]])\n",
+      "DenseOperator with data: \n",
+      "array([[ 1.+0.j,  0.+0.j],\n",
+      "       [ 0.+0.j, -1.+0.j]])\n",
+      "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
+      "Qobj data =\n",
+      "[[ 1.  0.]\n",
+      " [ 0. -1.]]\n",
+      "DenseOperator with data: \n",
+      "array([[ 1.+0.j,  0.+0.j],\n",
+      "       [ 0.+0.j, -1.+0.j]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import scipy.sparse as sp\n",
+    "from qutip import sigmaz\n",
+    "\n",
+    "pauli_z = DenseOperator(np.diag((1, -1)))\n",
+    "print(pauli_z)\n",
+    "pauli_z_from_sparse = DenseOperator(sp.csr_matrix(np.diag((1, -1))))\n",
+    "print(pauli_z_from_sparse)\n",
+    "print(sigmaz())\n",
+    "print(DenseOperator(sigmaz()))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The matrix arithmetic is overloaded to support intuitive matrix operation like\n",
+    "addition, multiplication, scalar multiplication and so on."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 * pauli_z =\n",
+      "DenseOperator with data: \n",
+      "array([[ 2.+0.j,  0.+0.j],\n",
+      "       [ 0.+0.j, -2.+0.j]])\n",
+      "pauli_z +  pauli_x =\n",
+      "DenseOperator with data: \n",
+      "array([[ 1.+0.j,  1.+0.j],\n",
+      "       [ 1.+0.j, -1.+0.j]])\n",
+      "pauli_x * pauli_z =\n",
+      "DenseOperator with data: \n",
+      "array([[ 0.+0.j, -1.+0.j],\n",
+      "       [ 1.+0.j,  0.+0.j]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "p_x = DenseOperator.pauli_x()\n",
+    "p_z = DenseOperator.pauli_z()\n",
+    "\n",
+    "print(\"2 * pauli_z =\")\n",
+    "print(2 * p_z)\n",
+    "print(\"pauli_z +  pauli_x =\")\n",
+    "print(p_z + p_x)\n",
+    "print(\"pauli_x * pauli_z =\")\n",
+    "print(p_x * p_z)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The operator class implements plenty of useful functions for quantum mechanics.\n",
+    "For example the kronecker matrix product and partial traces are included to\n",
+    "work with product spaces.\n",
+    "\n",
+    "Assume you describe two qubits and need an operator\n",
+    "$p = \\sigma_x \\otimes \\sigma_0$ that operates as\n",
+    "bit flip on the first qubit and as identity on the second qubit. Then this\n",
+    "operator is constructed as:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DenseOperator with data: \n",
+      "array([[0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n",
+      "       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],\n",
+      "       [1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
+      "       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "p = DenseOperator.pauli_x().kron(DenseOperator.pauli_0())\n",
+    "print(p)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "And taking the partial trace over the second space provides the bit flip gate:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DenseOperator with data: \n",
+      "array([[0.+0.j, 1.+0.j],\n",
+      "       [1.+0.j, 0.+0.j]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(.5 * p.ptrace(dims=[2, 2], remove=[1]))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "When calculating the partial trace, the argument 'dims' specifies the\n",
+    "dimensions of the subsystems and the argument 'remove' contains a list of the\n",
+    "subsystems that are to be traced over.\n",
+    "\n",
+    "Another useful function is the spectral decomposition:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Eigenvalues:\n",
+      "[-1.  1.]\n",
+      "Eigenvectors:\n",
+      "[[-0.70710678+0.j  0.70710678+0.j]\n",
+      " [ 0.70710678+0.j  0.70710678+0.j]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "eigenvalues, eigenvectors = p_x.spectral_decomposition(hermitian=True)\n",
+    "print('Eigenvalues:')\n",
+    "print(eigenvalues)\n",
+    "print('Eigenvectors:')\n",
+    "print(eigenvectors)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "And complex conjugation, transposition and the calculation of the adjoint\n",
+    "matrix are also supported:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Pauli Y:\n",
+      "DenseOperator with data: \n",
+      "array([[ 0.+0.j, -0.-1.j],\n",
+      "       [ 0.+1.j,  0.+0.j]])\n",
+      "Pauli Y complex conjugated:\n",
+      "DenseOperator with data: \n",
+      "array([[ 0.-0.j, -0.+1.j],\n",
+      "       [ 0.-1.j,  0.-0.j]])\n",
+      "Pauli Y complex transposed:\n",
+      "0j\n",
+      "Pauli Y complex adjoint:\n",
+      "DenseOperator with data: \n",
+      "array([[ 0.-0.j,  0.-1.j],\n",
+      "       [-0.+1.j,  0.-0.j]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "p_y = DenseOperator.pauli_y()\n",
+    "print('Pauli Y:')\n",
+    "print(p_y)\n",
+    "print('Pauli Y complex conjugated:')\n",
+    "print(p_y.conj())\n",
+    "print('Pauli Y complex transposed:')\n",
+    "print(p_y.tr())\n",
+    "print('Pauli Y complex adjoint:')\n",
+    "print(p_y.dag())"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "There are even more functions to be discovered in the API documentation."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "name": "python3",
+   "language": "python",
+   "display_name": "Python 3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/doc/source/qopt_features/qopt_features.rst b/doc/source/qopt_features/qopt_features.rst
index dea305c..5c717d7 100644
--- a/doc/source/qopt_features/qopt_features.rst
+++ b/doc/source/qopt_features/qopt_features.rst
@@ -15,3 +15,4 @@ from *Doc/source/qopt_features* using `jupyter notebook`.
    parallelization
    numerics
    energy_spectra_analyser
+   filter_functions_basic
diff --git a/doc/source/qopt_features/schroedinger_solver.ipynb b/doc/source/qopt_features/schroedinger_solver.ipynb
index 2c9268d..0b78f14 100644
--- a/doc/source/qopt_features/schroedinger_solver.ipynb
+++ b/doc/source/qopt_features/schroedinger_solver.ipynb
@@ -17,6 +17,8 @@
     "equations and a master equation in Lindblad form, and discuss the\n",
     "corresponding solver classes.)\n",
     "\n",
+    "## Schroedinger's Equation\n",
+    "\n",
     "The solver class computes the solution to Schroedinger's equation and is\n",
     "therefore of central importance to the simulation. The equation is given as:\n",
     "\n",
diff --git a/patch_notes.md b/patch_notes.md
index 8767f1b..34f6e2d 100644
--- a/patch_notes.md
+++ b/patch_notes.md
@@ -63,3 +63,31 @@ Optimizer:
 - improve storage. The optimizer is only stored in the result on request.
 
 ### Version 1.2 to 1.3
+
+GaussianMTF:
+- made the deprecation explicit
+
+Transfer Function:
+- new internal check function has more explicit error messages than previous
+  assertions.
+
+Energy Spectrum:
+- plotting reworked to be applicable to a larger number of dimensions in the 
+  Hamiltonian
+- Plotting function returns the figure and axis.
+
+Solver Algorithm:
+- the filter_function_h_n and noise_coeffs_derivatives change their signature, 
+now then are called with the optimization parameters, the transferred 
+parameters and the control amplitudes. Previously only with the control 
+amplitudes.
+
+Read the docs:
+- Add a new notebook about the basic use of filter functions in optimal control
+- Rework the notebook about the numerics. Now focused on the matrix class and 
+put at the start.
+- Add a new notebook about the use of filter functions in the optimization of 
+amplitude, frequency and phase noise.
+
+Optimizer:
+- Fix a false dimension check for the cost function weights.
diff --git a/qopt/cost_functions.py b/qopt/cost_functions.py
index 8caae7a..1311275 100644
--- a/qopt/cost_functions.py
+++ b/qopt/cost_functions.py
@@ -117,7 +117,9 @@ class CostFunction(ABC):
         Object that compute the forward/backward evolution and propagator.
 
     label: list of str
-        Indices of the returned infidelities for distinction in the analysis.
+        The label serves as internal name of the cost function values. The
+        DataContainer class uses the label to distinct cost functions when
+        storing the data.
 
     """
 
diff --git a/qopt/energy_spectrum.py b/qopt/energy_spectrum.py
index 3442a17..9494b55 100644
--- a/qopt/energy_spectrum.py
+++ b/qopt/energy_spectrum.py
@@ -34,6 +34,7 @@
 
 """
 
+import matplotlib as mpl
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -60,16 +61,16 @@ def vector_color_map(vectors: np.array):
 
     """
     assert len(vectors.shape) == 2
-    n = vectors.shape[0]
-    basis = np.asarray([
-        [1, 0, 0, 1, 1, 0, 1],
-        [0, 1, 0, 1, 0, 1, 1],
-        [0, 0, 1, 0, 1, 1, 1]
-    ])
-    basis = basis[:, :vectors.shape[1]]
-    values = np.einsum('ni,ji -> nj', np.abs(vectors), basis)
-    for i in range(n):
-        values[i, :] /= np.linalg.norm(values[i, :])
+
+    points_on_cmap = np.linspace(0, 1, vectors.shape[-1])
+    basis_colors = mpl.cm.get_cmap('brg')(points_on_cmap)
+    basis_colors = np.array(basis_colors)[:, :-1]
+    
+    values = np.einsum('ij, ni -> nj', basis_colors, np.abs(vectors))
+
+    # in this basis, the normalization to the rgb range is not preserved, thus it needs to be renormalized. 
+    values /= np.max(values, axis=-1)[..., None]
+
     return values
 
 
@@ -102,8 +103,9 @@ def plot_energy_spectrum(hamiltonian: List[OperatorMatrix],
         eigenvalues[i, :] = eig_val
         eigenvectors[i, :, :] = np.abs(eig_vec)
 
-    plt.figure()
+    fig, ax = plt.subplots()
     for i in range(d):
-        plt.scatter(x=x_val, y=eigenvalues[:, i],
-                    c=vector_color_map(eigenvectors[:, :, i]))
-    plt.xlabel(xlabel=x_label)
+        ax.scatter(x=x_val, y=eigenvalues[:, i],
+                   c=vector_color_map(eigenvectors[:, :, i]))
+    ax.set_xlabel(x_label)
+    return fig, ax
diff --git a/qopt/noise.py b/qopt/noise.py
index 81839f8..59c425c 100644
--- a/qopt/noise.py
+++ b/qopt/noise.py
@@ -118,7 +118,7 @@ def sample_1dim_gaussian_distribution(std1: float,
 
     Returns
     -------
-    selected_x: np.ndarray
+    selected_x: list of float
         Noise samples.
 
     """
diff --git a/qopt/optimize.py b/qopt/optimize.py
index 61dfbda..db5fb02 100644
--- a/qopt/optimize.py
+++ b/qopt/optimize.py
@@ -190,10 +190,6 @@ def __init__(
                 self.cost_func_weights).flatten()
             if len(self.cost_func_weights) == 0:
                 self.cost_func_weights = None
-            elif not len(self.system_simulator.cost_funcs) == len(
-                    self.cost_func_weights):
-                raise ValueError('A cost function weight must be specified for'
-                                 'each cost function or for none at all.')
 
     def cost_func_wrapper(self, optimization_parameters):
         """Wraps the cost function given by the simulator class.
@@ -384,9 +380,13 @@ class LeastSquaresOptimizer(Optimizer):
         The optimization method used. Currently implemented are:
         - 'trf': A trust region optimization algorithm. This is the default.
 
-    bounds: array or list of boundaries, optional
+    bounds: list of array-like, optional
+        Attention: The boundary format can vary between optimizers!
         The boundary conditions for the pulse optimizations. If none are given
-        then the pulse is assumed to take any real value.
+        then the pulse is assumed to take any real value. The boundaries are
+        given as a list of two arrays. The first array specifies the upper
+        and the second array specifies the lower bounds. Single parameters
+        can be excepted by using np.inf with appropriate sign.
 
     """
 
@@ -470,6 +470,13 @@ class ScalarMinimizingOptimizer(Optimizer):
     method: string
         Takes methods implemented by scipy.optimize.minimize.
 
+    bounds: sequence, optional
+        Attention: The boundary format can vary between optimizers!
+        The boundary conditions for the pulse optimizations. If none are given
+        then the pulse is assumed to take any real value. The boundaries are
+        given as a sequence of (min, max) pairs for each element. Defaults to
+        None.
+
     """
     def __init__(
             self,
diff --git a/qopt/solver_algorithms.py b/qopt/solver_algorithms.py
index 266dee3..d4b27ed 100644
--- a/qopt/solver_algorithms.py
+++ b/qopt/solver_algorithms.py
@@ -70,7 +70,8 @@
 from abc import ABC, abstractmethod
 from multiprocessing import Pool
 
-from filter_functions import pulse_sequence, plotting, basis, numeric
+from filter_functions import pulse_sequence, basis, numeric
+from filter_functions import plotting as ff_plotting
 
 from qopt import noise, matrix, matrix as q_mat
 from qopt.transfer_function import TransferFunction, IdentityTF
@@ -115,7 +116,11 @@ class Solver(ABC):
 
         The operators may be given either as NumPy arrays or QuTiP Qobjs
         and each coefficient array should have the same number of elements
-        as *dt*, and should be given in units of :math:`\hbar`. If not every
+        as *dt*, and should be given in units of :math:`\hbar`. Alternatively,
+        the argument can be a callable. This should have the signature of three
+        input arguments, which are (Optimization parameters, transferred
+        parameters, control amplitudes). The callable should return an nested
+        list of the form given above. If not every
         sublist (read operator) was given a identifier, they are automatically
         filled up with 'A_i' where i is the position of the operator.
         Alternatively the create_ff_h_n may be a function handle creating
@@ -537,7 +542,17 @@ def filter_function_n_coeffs_deriv_vals(self) -> Optional[np.ndarray]:
         if self.filter_function_n_coeffs_deriv is None:
             return None
         else:
-            return self.filter_function_n_coeffs_deriv(self._ctrl_amps)
+            try:
+                return self.filter_function_n_coeffs_deriv(
+                    self._opt_pars, self.transferred_parameters,
+                    self._ctrl_amps)
+            except TypeError:
+                print("Warning, you are used the old interface for the "
+                      "filter_functio_h_n. If you choose it as callable,"
+                      "it should receive the three arguments "
+                      "(optimization parameters, transferred parameters,"
+                      "control amplitudes). ")
+                return self.filter_function_n_coeffs_deriv(self._ctrl_amps)
 
     @property
     def create_ff_h_n(self) -> list:
@@ -552,7 +567,17 @@ def create_ff_h_n(self) -> list:
         if type(self._filter_function_h_n) == list:
             h_n = self._filter_function_h_n
         else:
-            h_n = self._filter_function_h_n(self._ctrl_amps)
+            try:
+                h_n = self._filter_function_h_n(
+                    self._opt_pars, self.transferred_parameters,
+                    self._ctrl_amps)
+            except TypeError:
+                print("Warning, you are used the old interface for the "
+                      "filter_functio_h_n. If you choose it as callable,"
+                      "it should receive the three arguments "
+                      "(optimization parameters, transferred parameters,"
+                      "control amplitudes). ")
+                h_n = self._filter_function_h_n(self._ctrl_amps)
 
         if not h_n:
             h_n = [[np.zeros(self.h_ctrl[0].shape),
@@ -656,6 +681,7 @@ def create_pulse_sequence(
                 raise ValueError('No optimization parameters set. '
                                  'Please supply new_amps argument')
 
+
         if ff_basis is not None:
             basis = ff_basis
         elif self.filter_function_basis is not None:
@@ -718,9 +744,10 @@ def plot_bloch_sphere(
         """
         # Already takes care of updating and cleaning the PulseSequence object
         pulse_sequence = self.create_pulse_sequence(new_amps=new_amps)
-        return plotting.plot_bloch_vector_evolution(pulse_sequence,
-                                                    n_samples=500,
-                                                    return_Bloch=return_Bloch)
+        return ff_plotting.plot_bloch_vector_evolution(
+            pulse_sequence,
+            n_samples=500,
+            return_Bloch=return_Bloch)
 
 
 class SchroedingerSolver(Solver):
@@ -1529,7 +1556,7 @@ class LindbladSolver(SchroedingerSolver):
 
     Parameters
     ----------
-    initial_diss_super_op: List[ControlMatrix], len num_l
+    initial_diss_super_op: List[ControlMatrix], len num_t
         Initial dissipation super operator; num_l is the number of
         Lindbladians. Set if you want to use (1.) (See documentation above!).
         The control matrices are expected to be of shape (dim, dim) where dim
diff --git a/qopt/transfer_function.py b/qopt/transfer_function.py
index 7aa5738..0ab0f73 100644
--- a/qopt/transfer_function.py
+++ b/qopt/transfer_function.py
@@ -470,6 +470,74 @@ def plot_pulse(self, y: np.array) -> None:
                     fill=False)
         plt.show()
 
+    def _check_dimensions_datatype(self, y: np.array) -> None:
+        """
+        This function verifies that the transfer function can be applied to
+        the pulse y. For this purpose, the shape and the data type of y must
+        fit the transfer function.
+
+        Parameters
+        ----------
+        y: np.array, shape (num_y, num_par)
+            Raw optimization variables; num_y is the number of time slices of
+            the raw optimization parameters and num_par is the number of
+            distinct raw optimization parameters.
+
+        Raises
+        ------
+        IndexError: is raised when the pulse has the wrong dimensions.
+
+        TypeError: is raised when the pulse has the wrong data type.
+
+        RuntimeError: is raised when the transfer function is not yet properly
+        initialised.
+
+        """
+
+        # check that the transfer function is correctly initialised.
+        if self._y_times is None:
+            raise RuntimeError(
+                'The times are not set to this instance of transfer functions.'
+                'Please use the function TransferFunction.set_times before '
+                'you continue.'
+            )
+
+        # check for the correct data type:
+        if not y.dtype in [np.float64, np.float32]:
+            raise TypeError(
+                'The transfer function assumes an input pulse as numpy array'
+                'of the dtype np.float32 or np.float64 but the given input'
+                'has type: ' + str(y.dtype)
+            )
+
+        # check for the correct data dimensions
+        shape = y.shape
+
+        if not len(shape) == 2:
+            raise IndexError(
+                'The input data pulse must be a numpy array with 2 dimensions,'
+                'but your pulse has ' + str(len(shape)) + ' dimensions.'
+            )
+
+        if not shape[0] == self._num_y:
+            raise IndexError(
+                'The pulse data must have exactly as many entries as there are'
+                'time steps. You have ' + str(self._num_y) +
+                ' time steps but there are ' + str(shape[0]) +
+                'entries in your pulse. Please make sure that you have set the'
+                'time steps correctly.'
+            )
+
+        if not shape[1] == self.num_ctrls:
+            raise IndexError(
+                'The pulse data must have exactly as many pulses as there are'
+                'control signals. You initialised this transfer function for'
+                + str(self.num_ctrls) +
+                'control signals but your pulse data has ' + str(shape[1]) +
+                'control pulses. Please make sure you set the parameter'
+                'num_ctrls correctly when initializing the transfer function.'
+            )
+
 
 class IdentityTF(TransferFunction):
     """Numerically efficient identity transfer function which does not change
@@ -545,6 +613,8 @@ def __call__(self, y: np.array) -> np.array:
             transferred optimization parameters.
 
         """
+        self._check_dimensions_datatype(y)
+
         # oversample pulse by repetition
         u = np.repeat(y, self.oversampling, axis=0)
 
@@ -651,11 +721,7 @@ def __call__(self, y: np.array) -> np.array:
             Control parameters; num_u is the number of times slices for the
             transferred optimization parameters.
         """
-        shape = y.shape
-        assert len(shape) == 2
-        assert shape[0] == self._num_y
-        assert shape[1] == self.num_ctrls
-        assert y.dtype in [np.float64, np.float32]
+        self._check_dimensions_datatype(y)
 
         return scipy.ndimage.convolve(
             y, weights=self.kernel, mode=self.mode, cval=self.cval
@@ -777,12 +843,13 @@ def __call__(self, y: np.array) -> np.array:
             Control parameters; num_u is the number of times slices for the
             transferred optimization parameters.
 
+        Raises
+        ------
+        ValueError: Indicating that the data shape or type of the argument is
+        incompatible with the transfer function configuration.
+
         """
-        shape = y.shape
-        assert len(shape) == 2
-        assert shape[0] == self._num_y
-        assert shape[1] == self.num_ctrls
-        assert y.dtype in [np.float64, np.float32]
+        self._check_dimensions_datatype(y)
 
         return scipy.ndimage.gaussian_filter1d(
             y, self.sigma, axis=0, order=self.order, mode=self.mode,
@@ -866,6 +933,7 @@ def __init__(self, tf1: TransferFunction, tf2: TransferFunction):
 
     def __call__(self, y: np.ndarray, *args, **kwargs):
         """Calls the concatenated transfer functions in sequence."""
+        self._check_dimensions_datatype(y)
         return self.tf2(self.tf1(y))
 
     def gradient_chain_rule(
@@ -953,6 +1021,7 @@ def __call__(self, y: np.array) -> np.array:
         concatenated.
 
         """
+        self._check_dimensions_datatype(y)
         return np.concatenate(
             (self.tf1(y[:, :self.tf1.num_ctrls]),
              self.tf2(y[:, self.tf1.num_ctrls:])),
@@ -1003,10 +1072,7 @@ def __call__(self, y: np.array) -> np.array:
             transferred optimization parameters.
 
         """
-        shape = y.shape
-        assert len(shape) == 2
-        assert shape[0] == self._num_y
-        assert shape[1] == self.num_ctrls
+        self._check_dimensions_datatype(y)
 
         if self._transfer_matrix is None:
             self._calculate_transfer_matrix()
@@ -1358,16 +1424,6 @@ def transfer_matrix(self) -> np.ndarray:
             self._calculate_transfer_matrix()
         return self._transfer_matrix
 
-    def __call__(self, y: np.ndarray) -> np.ndarray:
-        """See base class.
-        Todo: can be eliminated"""
-        if self._transfer_matrix is None:
-            self._calculate_transfer_matrix()
-        u = np.einsum('ijk,jk->ik', self._transfer_matrix, y)
-        if self.offset is not None:
-            u += self.offset
-        return u
-
     @deprecated
     def old_call(self, x: np.ndarray):
         """ `TODO` only alive for testing"""
@@ -1546,6 +1602,8 @@ def reverse_state(self, amplitudes=None, times=None, targetfunc=None):
 
 class GaussianMTF(MatrixTF):
     """
+    Deprecated! - Might be reimplemented upon reasonable request.
+
     Represent square function filtered through a gaussian filter.
 
     Can not be used in conjunction with the concatenate tf.
@@ -1573,6 +1631,7 @@ class GaussianMTF(MatrixTF):
 
     """
 
+    @deprecated
     def __init__(self, omega=1, over_sample_rate=5, start=0., end=0.,
                  bound_type=("w", 2)):
         super().__init__()


Test patch:
diff --git a/qopt_tests/unittests/test_transfer_functions.py b/qopt_tests/unittests/test_transfer_functions.py
index 76e5d35..25a053d 100644
--- a/qopt_tests/unittests/test_transfer_functions.py
+++ b/qopt_tests/unittests/test_transfer_functions.py
@@ -349,7 +349,7 @@ def test_exponential_transfer_function(self):
         ex.set_times(x_times)
 
         # test application of the transfer function
-        x = np.asarray([[1, 3, 2, 4],
+        x = np.asarray([[1., 3, 2, 4],
                         [1, 3, 2, 4]]).T
         u = ex(x)