diff --git a/notebooks/Measurement_Analysis.ipynb b/notebooks/Measurement_Analysis.ipynb
index 973657b..a59172f 100644
--- a/notebooks/Measurement_Analysis.ipynb
+++ b/notebooks/Measurement_Analysis.ipynb
@@ -5,37 +5,29 @@
    "id": "ca3c9c7af43b4e58",
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2025-09-03T09:11:36.449408Z",
-     "start_time": "2025-09-03T09:11:36.393235Z"
+     "end_time": "2025-09-03T12:09:25.759535Z",
+     "start_time": "2025-09-03T12:09:25.704514Z"
     }
    },
    "source": [
     "import sys\n",
-    "from time import sleep\n",
+    "#from PyQt5.QtGui.QRawFont import style\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import numpy as np\n",
+    "from IPython.display import clear_output\n",
+    "\n",
     "\n",
     "# Imports\n",
     "\n",
-    "from IPython.display import display, clear_output\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "import time\n",
-    "import threading\n",
-    "import os\n",
-    "import json\n",
-    "import glob\n",
-    "import numpy as np\n",
-    "from datetime import datetime, timedelta\n",
     "\n",
-    "import ipywidgets as widgets\n",
-    "from IPython.display import display\n",
-    "#from PyQt5.QtGui.QRawFont import style\n",
-    "from pywin.debugger import close\n",
-    "from scripts.regsetup import description\n",
-    "from webcolors import names\n",
-    "from pathlib import Path\n",
     "#TODO: Move script from frederica to scripts\n",
     "def check_path(path_str):\n",
+    "    \"\"\"\n",
+    "    Check if a path is valid, throws an exception if not.\n",
+    "    :param path_str:\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "    try:\n",
     "        path = Path(path_str)\n",
     "        if not path.exists():\n",
@@ -44,11 +36,11 @@
     "    except FileNotFoundError as e:\n",
     "        print(f\"Error: {e}\")\n",
     "\n",
+    "\n",
     "meas_scripts_dir = r\"C:\\Users\\berti_r\\Python_Projects\\metrology\\metrology\"\n",
     "meas_scripts_dir_local = r\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\Scripts\"\n",
     "config_path = r\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\Config\\config.json\"\n",
     "\n",
-    "\n",
     "#check_path(meas_scripts_dir)\n",
     "check_path(meas_scripts_dir_local)\n",
     "check_path(config_path)\n",
@@ -61,9 +53,7 @@
     "#import metrology_functions as mf\n",
     "import myutility as myu\n",
     "from matplotlib.widgets import Cursor\n",
-    "import ad\n",
-    "import sys\n",
-    "import os"
+    "import ad"
    ],
    "outputs": [
     {
@@ -83,7 +73,7 @@
    "metadata": {},
    "source": [
     "# General analysis tools\n",
-    "Statistics of all measurements, multiple plots drop down sith mesurement selection and statistical evaluation\n",
+    "Statistics of all measurements, multiple plots drop down sith mesurement selection a§nd statistical evaluation\n",
     "\n",
     "Collection of scripts for creating plots for different measurements, some scripts also include data processing which has to pe turned off/on in the code."
    ]
@@ -94,8 +84,8 @@
    "metadata": {
     "scrolled": true,
     "ExecuteTime": {
-     "end_time": "2025-09-03T09:18:21.231127Z",
-     "start_time": "2025-09-03T09:18:21.185128Z"
+     "end_time": "2025-09-03T12:20:15.835760Z",
+     "start_time": "2025-09-03T12:20:15.792013Z"
     }
    },
    "source": [
@@ -103,16 +93,15 @@
     "import ipywidgets as widgets\n",
     "from IPython.display import display\n",
     "import matplotlib.pyplot as plt\n",
-    "from mpl_fill_cmap_between import fill_cmap_between\n",
     "import pandas as pd\n",
-    "from mpl_toolkits.axes_grid1 import Divider, Size\n",
     "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
+    "\n",
     "plt.style.use('_mpl-gallery')\n",
     "\n",
     "# === CONFIGURATION ===\n",
     "# Values for coloring the std\n",
-    "minHalafstdy = 0.39 #Rolling statistics the half std for colouring green/orange\n",
-    "maxHalfstdy = 0.7   #Rolling statistics the half std for colouring orange/red\n",
+    "minHalafstdy = 0.39  #Rolling statistics the half std for colouring green/orange\n",
+    "maxHalfstdy = 0.7  #Rolling statistics the half std for colouring orange/red\n",
     "minHalafstdx = 0.39\n",
     "maxHalfstdx = 0.7\n",
     "\n",
@@ -125,10 +114,9 @@
     "#Cammera pole length in m\n",
     "camera_pole_length_m = 0.3\n",
     "#temperatur expansion coefficient(1D) for aluminium in mu/K/m\n",
-    "temp_exp_coeff_alu = 23\n",
+    "temp_exp_coeff_alu = 22#23.7\n",
     "temp_correction = 0\n",
     "\n",
-    "\n",
     "ROOT_DIR = rf\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\"  # ← Change this to your root directory\n",
     "# =====================\n",
     "output1 = widgets.Output()\n",
@@ -136,6 +124,8 @@
     "output3 = widgets.Output()\n",
     "output4 = widgets.Output()\n",
     "output5 = widgets.Output()\n",
+    "\n",
+    "\n",
     "def list_subfolders(path):\n",
     "    \"\"\"Return sorted list of subdirectories of a given path\"\"\"\n",
     "    if os.path.isdir(path):\n",
@@ -145,6 +135,7 @@
     "        ])\n",
     "    return []\n",
     "\n",
+    "\n",
     "# First dropdown: subfolders of ROOT_DIR\n",
     "first_dropdown = widgets.Dropdown(\n",
     "    options=list_subfolders(rf\"{ROOT_DIR}\\data\"),\n",
@@ -159,9 +150,15 @@
     "    layout=widgets.Layout(width='50%')\n",
     ")\n",
     "\n",
+    "\n",
     "def init_correcrtion():\n",
+    "    \"\"\"\n",
+    "    Temperature correction is turned on per default\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "    return 1\n",
     "\n",
+    "\n",
     "displyscatter = widgets.Button(description='Display Scatterplot', layout=widgets.Layout(width='50%'))\n",
     "displyFFT = widgets.Button(description='Display PFT', layout=widgets.Layout(width='50%'))\n",
     "displyRaw = widgets.Button(description='Display RAW', layout=widgets.Layout(width='50%'))\n",
@@ -173,39 +170,58 @@
     "\n",
     "displyStatistics = widgets.Button(description='Rolling Statistics', layout=widgets.Layout(width='50%'))\n",
     "\n",
+    "\n",
     "# Function to update second dropdown when first changes\n",
     "def on_button_clicked(o):\n",
+    "    \"\"\"\n",
+    "    Callback executed when button was clicked for the Scatter Plot\n",
+    "    :param o:\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "    with output1:\n",
     "        clear_output()\n",
     "        print(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
     "        display_my(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
+    "\n",
+    "\n",
     "def on_button_clicked_ft(o):\n",
+    "    \"\"\"\n",
+    "    Callback executed when button was clicked for the PFT\n",
+    "    :param o:\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "    with output1:\n",
     "        clear_output()\n",
     "        print(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
     "        display_my_ft(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
+    "\n",
+    "\n",
     "def on_btn_clicked_raw(o):\n",
     "    with output3:\n",
     "        clear_output()\n",
     "        print(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
     "        display_raw(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
+    "\n",
+    "\n",
     "def on_btn_clicked_stat(o):\n",
     "    with output4:\n",
     "        clear_output()\n",
     "        print(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
     "        rolling(rf\"{ROOT_DIR}\\data\\{first_dropdown.value}\\{second_dropdown.value}\")\n",
     "\n",
+    "\n",
     "def update_second_dropdown(change):\n",
     "    selected_folder = os.path.join(rf\"{ROOT_DIR}\\data\", change['new'])\n",
     "    subfolders = list_subfolders(selected_folder)\n",
     "    second_dropdown.options = subfolders if subfolders else [\"<no subfolders>\"]\n",
     "    second_dropdown.value = subfolders[-1] if subfolders else \"<no subfolders>\"\n",
     "\n",
+    "\n",
     "def set_temp_correction(change_c):\n",
-    "    new_state = 1 if change_c['new']==1 else 0\n",
+    "    new_state = 1 if change_c['new'] == 1 else 0\n",
     "    conf_corr = myu.load_object(rf\"{ROOT_DIR}\\Config\\display.json\")\n",
     "    conf_corr['temp_correction'] = new_state\n",
-    "    myu.save_config(rf\"{ROOT_DIR}\\Config\\display.json\",conf_corr)\n",
+    "    myu.save_config(rf\"{ROOT_DIR}\\Config\\display.json\", conf_corr)\n",
     "\n",
     "    with output5:\n",
     "        clear_output()\n",
@@ -223,81 +239,40 @@
     "# Display the widgets\n",
     "display(first_dropdown, second_dropdown)\n",
     "\n",
+    "\n",
     "#------------------------------------------------------------------------------------------------\n",
     "def get_pixel_size(path):\n",
+    "    \"\"\"\n",
+    "    returns the pixle size which should be saved in a json file alongside the measurement\n",
+    "    :param path: Path to the json file, Must include a Variable : pixel_size_mu\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "    config = myu.load_object(path)\n",
     "    return config.get(\"pixel_size_mu\")\n",
-    "def scatter_hist(x, y, ax, ax_histx, ax_histy):\n",
-    "    # no labels\n",
-    "    ax_histx.tick_params(axis=\"x\", labelbottom=False)\n",
-    "    ax_histy.tick_params(axis=\"y\", labelleft=False)\n",
     "\n",
-    "    # the scatter plot:\n",
-    "    ax.scatter(x, y)\n",
-    "\n",
-    "    # now determine nice limits by hand:\n",
-    "    binwidth = 0.15\n",
-    "    xmax = np.max(np.abs(x))\n",
-    "    xmin = np.min(np.abs(x))\n",
-    "    ymin = np.min(np.abs(y))\n",
-    "    ymax = np.max(np.abs(y))\n",
-    "    neglimx = (int(xmin)/binwidth+1)*binwidth\n",
-    "    neglimy = (int(ymin)/binwidth+1)*binwidth\n",
-    "    limx = (int(xmax/binwidth) + 1) * binwidth\n",
-    "    limy = (int(ymax/binwidth) + 1) * binwidth\n",
-    "\n",
-    "        #---------------stats------------\n",
-    "        #Calc statistics\n",
-    "    rms_x = np.sqrt(np.mean(np.square(x)))\n",
-    "    rms_y = np.sqrt(np.mean(np.square(y)))\n",
-    "    max_x = max(x)+0.1\n",
-    "    max_y = max(y)+0.1\n",
-    "    min_x = min(x)-0.1\n",
-    "    min_y = min(y)-0.1\n",
-    "    std_x = np.std(x)\n",
-    "    std_y = np.std(y)\n",
-    "    x_p2v = max_x-min_x\n",
-    "    y_p2v = max_y-min_y\n",
-    "\n",
-    "\n",
-    "    textstr = (f'Statistics| X  |  Y |\\n'\n",
-    "      f'    STD   |{std_x:.2f}|{std_y:.2f}|\\n'\n",
-    "      f'    P2V   |{x_p2v:.2f}|{y_p2v:.2f}|\\n ')\n",
-    "\n",
-    "    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
-    "\n",
-    "# place a text box in upper left in axes coords\n",
-    "    ax.text(0.05, 0.95, textstr, transform=ax.transAxes, fontsize=10,\n",
-    "        verticalalignment='top', bbox=props)\n",
-    "\n",
-    "    bins_x = np.arange(neglimx, limx + binwidth, binwidth)\n",
-    "    bins_y = np.arange(neglimy, limy + binwidth, binwidth)\n",
-    "    ax_histx.hist(x, bins=bins_x)\n",
-    "    ax_histy.hist(y, bins=bins_y, orientation='horizontal')\n",
     "\n",
     "def display_my(path):\n",
+    "    \"\"\"\n",
+    "    Plots  a scatter plot with aligned histograms\n",
+    "    :param path:\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "\n",
     "    axis_data_file_path_1 = myu.find_newest_dat_file(path)\n",
     "    #mf.analyze_repeatability(axis_data_file_path_1,1.1)\n",
     "\n",
-    "\n",
     "    x_vals1, y_vals1, times1 = myu.load_xy_data(axis_data_file_path_1)\n",
     "    #x_vals1 = x_vals1- np.mean(x_vals1)\n",
     "    #y_vals1 = y_vals1- np.mean(y_vals1)\n",
     "\n",
     "    # Fixing random state for reproducibility\n",
     "\n",
-    "\n",
     "    # some random data\n",
     "    conf_path = path.split(\"\\\\\")[-1]\n",
     "    conf_path = conf_path.split(\"_\")[0]\n",
     "    print(conf_path)\n",
-    "    x = x_vals1*get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
-    "    y = y_vals1*get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
+    "    x = x_vals1 * get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
+    "    y = y_vals1 * get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
     "\n",
     "    fig, ax = plt.subplots(figsize=(5.5, 5.5))\n",
     "\n",
@@ -321,8 +296,8 @@
     "    binwidth = 0.15\n",
     "    xymax = max(np.max(np.abs(x)), np.max(np.abs(y)))\n",
     "    xymin = min(np.min(np.abs(x)), np.min(np.abs(y)))\n",
-    "    limP = (int(xymax/binwidth) +0.01)*binwidth\n",
-    "    limM = (int(xymin/binwidth) -0.01)*binwidth\n",
+    "    limP = (int(xymax / binwidth) + 0.01) * binwidth\n",
+    "    limM = (int(xymin / binwidth) - 0.01) * binwidth\n",
     "\n",
     "    bins = np.arange(limM, limP + binwidth, binwidth)\n",
     "    ax_histx.hist(x, bins=bins)\n",
@@ -337,36 +312,46 @@
     "\n",
     "    plt.show()\n",
     "\n",
-    "\n",
-    "\n",
-    "    import matplotlib.mlab as mlab\n",
-    "\n",
     "    # Fixing random state for reproducibility\n",
+    "\n",
+    "\n",
     "def display_my_ft(path):\n",
+    "    \"\"\"\n",
+    "    Plots the time data of the Y Axis (can be cahned to X in code) and the coresponding fourier TF\n",
+    "    :param path:\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "    axis_data_file_path_1 = myu.find_newest_dat_file(path)\n",
     "\n",
-    "\n",
-    "\n",
     "    x_vals1, y_vals1, times1 = myu.load_xy_data(axis_data_file_path_1)\n",
     "\n",
     "    conf_path = path.split(\"\\\\\")[-1]\n",
     "    conf_path = conf_path.split(\"_\")[0]\n",
     "    print(conf_path)\n",
-    "    x = x_vals1*get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
-    "    y = y_vals1*get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
-    "    dt = 60\n",
-    "    t = np.arange(0, len(x)*dt, dt)\n",
+    "    x = x_vals1 * get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
+    "    y = y_vals1 * get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
+    "    x = x[a:b]\n",
+    "    y = y - np.mean(x)\n",
+    "    y = y[a:b]\n",
+    "    dt = (pd.Timedelta(times1[1] - times1[0]).seconds)\n",
     "\n",
+    "    t = np.arange(0, len(x) * dt, dt)\n",
     "\n",
     "    fig, (ax0, ax1) = plt.subplots(2, 1, layout='constrained', figsize=(10, 6))\n",
     "    ax0.plot(t, y)\n",
     "    ax0.set_xlabel('Time (s)')\n",
     "    ax0.set_ylabel('Signal')\n",
-    "    ax1.psd(y, NFFT=512, Fs=1 / dt)\n",
+    "    ax1.magnitude_spectrum(y, Fs=1 / dt, scale='linear')\n",
     "\n",
     "    plt.show()\n",
     "\n",
+    "\n",
     "def display_raw(path):\n",
+    "    \"\"\"\n",
+    "    Plots the raw data with std deviation and mean\n",
+    "    :param path:\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "    axis_data_file_path_1 = myu.find_newest_dat_file(path)\n",
     "    x_vals1, y_vals1, times1 = myu.load_xy_data(axis_data_file_path_1)\n",
     "    print(\"h\")\n",
@@ -427,52 +412,54 @@
     "    plt.tight_layout()\n",
     "    plt.show()\n",
     "\n",
+    "\n",
     "def rolling(path):\n",
+    "    \"\"\"\n",
+    "    plots the mean (15 minutes) as solid line and the standard deviation in that time as collared area, color changes according to std\n",
+    "    limits for collor coding can be set at the beginning of the script\n",
+    "    The temperature data is automaticly the newest file for older measurements it needs to be selected manualy\n",
+    "    :param path:\n",
+    "    :return:\n",
+    "    \"\"\"\n",
     "\n",
-    "\n",
-    "    #path to folders\n",
+    "    # Retreving the measurement data\n",
     "    axis_data_file_path_1 = myu.find_newest_dat_file(path)\n",
     "    data_folder = rf'{ROOT_DIR}\\data\\Temp'\n",
     "    file_path = myu.find_newest_dat_file(data_folder)\n",
     "\n",
     "    x_vals1, y_vals1, times1 = myu.load_xy_data(axis_data_file_path_1)\n",
-    "    timesT, temps = myu.load_temp_data(file_path)\n",
-    "\n",
-    "\n",
-    "    df1 = pd.DataFrame({'temp': temps[2][:]},index=timesT)\n",
-    "    df1 = df1.rolling('60min').mean()\n",
-    "\n",
+    "    timesT, temps = myu.load_temp_data(\n",
+    "       file_path) #                              <-------------- Insert here the Temperature meas Path\n",
+    "    # Conversion to dataframe for eas of processing\n",
+    "    df1 = pd.DataFrame({'temp': temps[2][:]}, index=timesT)\n",
+    "    df1 = df1.rolling('75min').mean()\n",
     "\n",
     "    #Getting the mesurement config file\n",
     "    conf_path = path.split(\"\\\\\")[-1]\n",
     "    conf_path = conf_path.split(\"_\")[0]\n",
     "    print(conf_path)\n",
     "\n",
-    "\n",
     "    # Convert pixel values and slice the relevant time window\n",
     "    scale = get_pixel_size(rf\"{path}\\conf_{conf_path}.json\")\n",
     "    x = (x_vals1 * scale)[a:b]\n",
     "    y = (y_vals1 * scale)[a:b]\n",
     "    times1 = times1[a:b]\n",
     "\n",
-    "\n",
     "    df_x = pd.DataFrame({'x': x}, index=times1)\n",
     "    df_y = pd.DataFrame({'y': y}, index=times1)\n",
     "\n",
-    "\n",
-    "    merged= pd.merge_asof(df_y,df1,left_index=True, right_index=True)\n",
+    "    # Matching Temperature to measurment for temperature correction\n",
+    "    merged = pd.merge_asof(df_y, df1, left_index=True, right_index=True)\n",
     "    for index, row in merged.iterrows():\n",
-    "        merged.at[index, 'y'] = merged.at[index, 'y']+(camera_pole_length_m*temp_exp_coeff_alu*(ref_temp-merged.at[index, 'temp']))\n",
-    "\n",
-    "\n",
+    "        merged.at[index, 'y'] = merged.at[index, 'y'] + (\n",
+    "                camera_pole_length_m * temp_exp_coeff_alu * (ref_temp - merged.at[index, 'temp']))\n",
     "\n",
     "    rolling_std_x = df_x.rolling('15min').std()\n",
     "    rolling_std_y = df_y.rolling('15min').std()\n",
     "    rolling_avg_x = df_x.rolling('15min').mean()\n",
     "    rolling_avg_y = df_y.rolling('15min').mean()\n",
     "\n",
-    "    rolling_avg_merged = merged.rolling('5min').mean()\n",
-    "\n",
+    "    rolling_avg_merged = merged.rolling('15min').mean()\n",
     "\n",
     "    #spann the standard deviation as lightli colourd area and the meam as solid line\n",
     "    y_high_std = rolling_avg_y['y'].to_numpy() + rolling_std_y['y'].to_numpy()\n",
@@ -490,9 +477,8 @@
     "        f'    STD   |{stdx:.2f}|{stdy:.2f}|\\n'\n",
     "    )\n",
     "\n",
-    "\n",
     "    # Create subplots\n",
-    "    fig_raw, (ax1_raw, ax2_raw) = plt.subplots(2, 1, figsize=(10, 6), sharex=True,sharey=True)\n",
+    "    fig_raw, (ax1_raw, ax2_raw) = plt.subplots(2, 1, figsize=(10, 6), sharex=True, sharey=True)\n",
     "\n",
     "    # Optionally add statistics as a text box\n",
     "    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
@@ -501,52 +487,47 @@
     "\n",
     "    # The first items are for padding and the second items are for the Axes.\n",
     "    # Plot x over time with mean and ±std deviation\n",
-    "    ax1_raw.plot(times1, rolling_avg_x['x'].to_numpy(),linewidth= 0.5 , label=\"X Position\")\n",
+    "    ax1_raw.plot(times1, rolling_avg_x['x'].to_numpy(), linewidth=0.5, label=\"X Position\")\n",
     "    diff_x = (x_high_std - x_low_std)\n",
-    "    ax1_raw.fill_between(times1, x_high_std, x_low_std,linewidth=0, alpha=0.5,facecolor='green',where=diff_x<minHalafstdx)\n",
-    "    ax1_raw.fill_between(times1, x_high_std, x_low_std,linewidth=0, alpha=0.5,facecolor='orange',where=((diff_x >= minHalafstdx) & (diff_x <= maxHalfstdx)))\n",
-    "    ax1_raw.fill_between(times1, x_high_std, x_low_std,linewidth=0, alpha=0.5,facecolor='red',where=diff_x>maxHalfstdx)\n",
+    "    ax1_raw.fill_between(times1, x_high_std, x_low_std, linewidth=0, alpha=0.5, facecolor='green',\n",
+    "                         where=diff_x < minHalafstdx)\n",
+    "    ax1_raw.fill_between(times1, x_high_std, x_low_std, linewidth=0, alpha=0.5, facecolor='orange',\n",
+    "                         where=((diff_x >= minHalafstdx) & (diff_x <= maxHalfstdx)))\n",
+    "    ax1_raw.fill_between(times1, x_high_std, x_low_std, linewidth=0, alpha=0.5, facecolor='red',\n",
+    "                         where=diff_x > maxHalfstdx)\n",
     "\n",
     "\n",
-    "\n",
-    "    # Optionally add statistics as a text box\n",
-    "    \"\"\"props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
-    "    ax1_raw.text(0.02, 0.95, textstra, transform=ax1_raw.transAxes, fontsize=10,\n",
-    "                 verticalalignment='top', bbox=props)\"\"\"\n",
-    "\n",
     "    ax1_raw.set_xlabel('Time (s)')\n",
     "    ax1_raw.set_ylabel('X Position')\n",
     "    ax1_raw.legend()\n",
     "    ax1_raw.margins(0.05)\n",
     "\n",
-    "\n",
-    "\n",
     "    diff_y = (y_high_std - y_low_std)\n",
     "\n",
     "    # Plot y over time\n",
-    "    ax2_raw.plot(times1, rolling_avg_y['y'].to_numpy(),linewidth= 0.5  , label=\"Y avg Position\")\n",
+    "    ax2_raw.plot(times1, rolling_avg_y['y'].to_numpy(), linewidth=0.5, label=\"Y avg Position\")\n",
     "    corr_conf = myu.load_object(rf\"{ROOT_DIR}\\Config\\display.json\")\n",
-    "    if corr_conf.get(\"temp_correction\")==1:\n",
-    "        ax2_raw.plot(rolling_avg_merged.index.to_numpy(), rolling_avg_merged['y'].to_numpy(),linewidth= 0.5,c='purple'  , label=\"camera pole temp corrected Position\")\n",
-    "    ax2_raw.fill_between(times1, y_high_std, y_low_std,linewidth=0, alpha=0.5,facecolor='green',where=diff_y<minHalafstdy)\n",
-    "    ax2_raw.fill_between(times1, y_high_std, y_low_std,linewidth=0, alpha=0.5,facecolor='orange',where=((diff_y >= minHalafstdy) & (diff_y <= maxHalfstdy)))\n",
-    "    ax2_raw.fill_between(times1, y_high_std, y_low_std,linewidth=0, alpha=0.5,facecolor='red',where=diff_y>maxHalfstdy)\n",
-    "\n",
-    "\n",
-    "\n",
+    "    if corr_conf.get(\"temp_correction\") == 1:\n",
+    "        ax2_raw.plot(rolling_avg_merged.index.to_numpy(), rolling_avg_merged['y'].to_numpy(), linewidth=0.5, c='purple',\n",
+    "                     label=\"camera pole temp corrected Position\")\n",
+    "    ax2_raw.fill_between(times1, y_high_std, y_low_std, linewidth=0, alpha=0.5, facecolor='green',\n",
+    "                         where=diff_y < minHalafstdy)\n",
+    "    ax2_raw.fill_between(times1, y_high_std, y_low_std, linewidth=0, alpha=0.5, facecolor='orange',\n",
+    "                         where=((diff_y >= minHalafstdy) & (diff_y <= maxHalfstdy)))\n",
+    "    ax2_raw.fill_between(times1, y_high_std, y_low_std, linewidth=0, alpha=0.5, facecolor='red',\n",
+    "                         where=diff_y > maxHalfstdy)\n",
     "\n",
     "    ax2_raw.set_xlabel('Time (s)')\n",
     "    ax2_raw.set_ylabel('Y Position')\n",
     "    ax2_raw.legend()\n",
     "    ax2_raw.margins(0.05)\n",
     "\n",
-    "\n",
     "    plt.tight_layout()\n",
     "\n",
     "    plt.show()\n",
     "\n",
     "\n",
-    "\n",
+    "#-------------------------------------------displaying the widgets and unmasiking IRQs-----------------------------------\n",
     "displyscatter.on_click(on_button_clicked)\n",
     "displyRaw.on_click(on_btn_clicked_raw)\n",
     "displyFFT.on_click(on_button_clicked_ft)\n",
@@ -556,7 +537,7 @@
     "display(displyRaw, output3)\n",
     "display(displyStatistics, output4)\n",
     "tempCorrectionBtn.observe(set_temp_correction, names='value')\n",
-    "display(tempCorrectionBtn,output5)\n"
+    "display(tempCorrectionBtn, output5)\n"
    ],
    "outputs": [
     {
@@ -567,7 +548,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "94c0dae5adb947f5bbee31283d75a323"
+       "model_id": "2ab8cfdaf53e461396894a336fd18795"
       }
      },
      "metadata": {},
@@ -581,7 +562,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "b87eaba00c4446ce91c03d16c6d7aff8"
+       "model_id": "3f38933ef65b47838f20ba5978579234"
       }
      },
      "metadata": {},
@@ -595,7 +576,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "a6b072252eff4e99b9eb6d001c214a20"
+       "model_id": "efe4e8a3fb0e4986a1fdc67eed25667e"
       }
      },
      "metadata": {},
@@ -609,7 +590,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "adae3df1efa745ebb586a35354715c54"
+       "model_id": "90aaa9d3280c4bbd8de20af6dc1570da"
       }
      },
      "metadata": {},
@@ -623,7 +604,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "7308eed6d70d4b9a8bfb36e9271de1ba"
+       "model_id": "39c34000911d4eb9911844d433e1a3d4"
       }
      },
      "metadata": {},
@@ -637,7 +618,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "2701a20100864586a13a516c38498ff1"
+       "model_id": "0871a6f5a1c24cdc844722e4232eab30"
       }
      },
      "metadata": {},
@@ -651,7 +632,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "b3092f1a437a4ed4be516bad208ae871"
+       "model_id": "45bba3f5a2674ca8887c5b0f01019cab"
       }
      },
      "metadata": {},
@@ -665,7 +646,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "8eb3322e708541a6a9ee8d01f2f11d2b"
+       "model_id": "a58df19e74104bf1904c0df3e4df6ed1"
       }
      },
      "metadata": {},
@@ -679,7 +660,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "647d2e66779a487f9cdfc24809ae50be"
+       "model_id": "82cedb39c8924af8a3148efea990ec78"
       }
      },
      "metadata": {},
@@ -693,7 +674,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "aa7a7ce839fe487daf706f18e1e637ca"
+       "model_id": "1ab2f0e7a3664adf9e9cdd7d145c1f49"
       }
      },
      "metadata": {},
@@ -707,7 +688,7 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "05e08f4683974a90a02f97a4e03ad1e6"
+       "model_id": "ec6a35d1ee3141db89e64224ab5488fc"
       }
      },
      "metadata": {},
@@ -721,14 +702,14 @@
       "application/vnd.jupyter.widget-view+json": {
        "version_major": 2,
        "version_minor": 0,
-       "model_id": "35c1735497ce46f1b9e28002757e3209"
+       "model_id": "20b53fcbe8b24342b0a0fffb5701e26b"
       }
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
-   "execution_count": 6
+   "execution_count": 12
   },
   {
    "metadata": {},
@@ -743,7 +724,12 @@
    "id": "ca5359d36ec7f8ff"
   },
   {
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-03T12:09:26.016279Z",
+     "start_time": "2025-09-03T12:09:25.862150Z"
+    }
+   },
    "cell_type": "code",
    "source": [
     "data_folder = r'C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\data\\Temp'\n",
@@ -756,26 +742,26 @@
     "file_path = myu.find_newest_dat_file(data_folder)\n",
     "times, temps = myu.load_temp_data(file_path)\n",
     "\n",
-    "\n",
     "# Initial plot range setup\n",
     "initial_xlim = (mdates.date2num(times[0]), mdates.date2num(times[-1]))\n",
     "colors = ['red', 'green', 'blue', 'orange', 'purple']\n",
-    "labels = [f\"Chanel {i+1}\" for i in range(5)]\n",
+    "labels = [f\"Chanel {i + 1}\" for i in range(5)]\n",
     "\n",
     "# Setup plot\n",
     "fig_temp, ax = plt.subplots(figsize=(10, 5))\n",
     "lines = []\n",
     "\n",
+    "\n",
     "# Plot initial downsampled data\n",
     "def plot_initial():\n",
     "    ind_min, ind_max = 0, len(times)\n",
     "    step = max((ind_max - ind_min) // 1000, 1)\n",
     "\n",
     "    for i in range(5):\n",
-    "        if   (i==2): # 2 ist raum\n",
+    "        if (i == 2):  # 2 ist raum\n",
     "            line, = ax.plot(times[ind_min:ind_max:step],\n",
-    "                        temps[i][ind_min:ind_max:step],\n",
-    "                        label=labels[i], color=colors[i])\n",
+    "                            temps[i][ind_min:ind_max:step],\n",
+    "                            label=labels[i], color=colors[i])\n",
     "            lines.append(line)\n",
     "\n",
     "    ax.set_title(\"Temperature over time\")\n",
@@ -785,7 +771,8 @@
     "    ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
     "    ax.set_xlim(initial_xlim)\n",
     "    ax.relim()\n",
-    "    #ax.autoscale_view()\n",
+    "\n",
+    "\n",
     "\n",
     "# Update on zoom/pan\n",
     "def update_plot(event=None):\n",
@@ -796,16 +783,17 @@
     "    step = max((ind_max - ind_min) // 1000, 1)\n",
     "\n",
     "    for i in range(5):\n",
-    "        if   (i==2): # 2 ist raum\n",
+    "        if (i == 2):  # 2 ist raum\n",
     "            line, = ax.plot(times[ind_min:ind_max:step],\n",
-    "                        temps[i][ind_min:ind_max:step],\n",
-    "                        label=labels[i], color=colors[i])\n",
+    "                            temps[i][ind_min:ind_max:step],\n",
+    "                            label=labels[i], color=colors[i])\n",
     "            lines.append(line)\n",
     "\n",
     "    ax.relim()\n",
     "    ax.autoscale_view()\n",
     "    fig_temp.canvas.draw_idle()\n",
     "\n",
+    "\n",
     "# Hook zoom & pan events\n",
     "#fig_temp.canvas.mpl_connect('button_release_event', update_plot)\n",
     "#fig_temp.canvas.mpl_connect('scroll_event', update_plot)\n",
@@ -818,14 +806,51 @@
     "#fig_temp.canvas.draw_idle()"
    ],
    "id": "52db5e2c12fea30c",
-   "outputs": [],
-   "execution_count": null
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ],
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=1000.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "application/vnd.jupyter.widget-view+json": {
+       "version_major": 2,
+       "version_minor": 0,
+       "model_id": "db1b0937a47041a48dc98d3949f1dc20"
+      }
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 3
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Analysis for Static\n",
+    "This script can be used for statistical analysis of a static measurement, where no axis is moved. This was done to establish a baseline. It only looks for files in the past week. Older files wont get selected.\n",
+    "\n",
+    "The pooling variable was used for condensing data down, acts as a LP filter but not quite."
+   ],
+   "id": "9460bbadd8e9774b"
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2025-09-03T09:25:03.496022Z",
-     "start_time": "2025-09-03T09:25:03.108257Z"
+     "end_time": "2025-09-03T12:09:26.403640Z",
+     "start_time": "2025-09-03T12:09:26.023820Z"
     }
    },
    "cell_type": "code",
@@ -833,6 +858,7 @@
     "pooling = 0\n",
     "STATIC_LOG_FILE = \"CSV_logs/static_tests_log.csv\"\n",
     "\n",
+    "\n",
     "def log_static_test(x_std, y_std, x_p2v, y_p2v, nr_of_cycles=0, path=None):\n",
     "    if path is None:\n",
     "        masiv = myu.get_latest_measurement_dir(1)\n",
@@ -842,7 +868,7 @@
     "        singel = path.split(\"\\\\\")\n",
     "\n",
     "    new_entry = pd.DataFrame([{\n",
-    "        \"day_time\":singel[-1],\n",
+    "        \"day_time\": singel[-1],\n",
     "        \"x_std\": x_std,\n",
     "        \"y_std\": y_std,\n",
     "        \"x_p2v\": x_p2v,\n",
@@ -858,6 +884,7 @@
     "    new_log.to_csv(STATIC_LOG_FILE, index=False)\n",
     "    print(\"Static test logged.\")\n",
     "\n",
+    "\n",
     "def remove_duplicate_static_tests(log_file=\"static_tests_log.csv\"):\n",
     "    if not os.path.exists(log_file):\n",
     "        print(f\"No such file: {log_file}\")\n",
@@ -873,6 +900,7 @@
     "    df_clean.to_csv(log_file, index=False)\n",
     "    print(f\"Removed duplicates. {len(df) - len(df_clean)} rows deleted.\")\n",
     "\n",
+    "\n",
     "def get_pixel_size():\n",
     "    config = myu.load_object(config_path)\n",
     "    return config.get(\"pixel_size_mu\")\n",
@@ -883,6 +911,8 @@
     "#axis_path_1 = r\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\data\\data20250718_alignment_tests\\20250718_113013_static_0\" #uncomment for specific path\n",
     "axis_data_file_path_1 = myu.find_newest_dat_file(axis_path_1)\n",
     "print(axis_data_file_path_1)\n",
+    "\n",
+    "\n",
     "#mf.analyze_repeatability(axis_data_file_path_1,1.1)\n",
     "\n",
     "\n",
@@ -898,35 +928,33 @@
     "    pooled = data.reshape(-1, pool_size).mean(axis=1)\n",
     "    return pooled\n",
     "\n",
+    "\n",
     "if pooling == 1:\n",
     "    x_vals1, y_vals1, times1 = myu.load_xy_data(axis_data_file_path_1)\n",
     "\n",
-    "    x_vals = pool_average_1d(x_vals1,10)\n",
-    "    y_vals = pool_average_1d(y_vals1,10)\n",
+    "    x_vals = pool_average_1d(x_vals1, 10)\n",
+    "    y_vals = pool_average_1d(y_vals1, 10)\n",
     "    times = times1[:len(x_vals)]\n",
-    "    x_vals = x_vals*get_pixel_size()\n",
-    "    y_vals = y_vals*get_pixel_size()\n",
+    "    x_vals = x_vals * get_pixel_size()\n",
+    "    y_vals = y_vals * get_pixel_size()\n",
     "if pooling == 0:\n",
     "    x_vals, y_vals, times = myu.load_xy_data(axis_data_file_path_1)\n",
-    "    x_vals = x_vals*get_pixel_size()\n",
-    "    y_vals = y_vals*get_pixel_size()\n",
-    "\n",
-    "\n",
+    "    x_vals = x_vals * get_pixel_size()\n",
+    "    y_vals = y_vals * get_pixel_size()\n",
     "\n",
     "#Calc statistics\n",
     "rms_x = np.sqrt(np.mean(np.square(x_vals)))\n",
     "rms_y = np.sqrt(np.mean(np.square(y_vals)))\n",
-    "max_x = max(x_vals)+0.1\n",
-    "max_y = max(y_vals)+0.1\n",
-    "min_x = min(x_vals)-0.1\n",
-    "min_y = min(y_vals)-0.1\n",
+    "max_x = max(x_vals) + 0.1\n",
+    "max_y = max(y_vals) + 0.1\n",
+    "min_x = min(x_vals) - 0.1\n",
+    "min_y = min(y_vals) - 0.1\n",
     "std_x = np.std(x_vals)\n",
     "std_y = np.std(y_vals)\n",
-    "x_p2v = max_x-min_x\n",
-    "y_p2v = max_y-min_y\n",
+    "x_p2v = max_x - min_x\n",
+    "y_p2v = max_y - min_y\n",
     "\n",
-    "\n",
-    "log_static_test(std_x, std_y, x_p2v, y_p2v,len(x_vals),axis_path_1)\n",
+    "log_static_test(std_x, std_y, x_p2v, y_p2v, len(x_vals), axis_path_1)\n",
     "remove_duplicate_static_tests()\n",
     "\n",
     "print(f'Statistics| X  |  Y |\\n'\n",
@@ -1038,63 +1066,14 @@
      "traceback": [
       "\u001B[31m---------------------------------------------------------------------------\u001B[39m",
       "\u001B[31mTypeError\u001B[39m                                 Traceback (most recent call last)",
-      "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[7]\u001B[39m\u001B[32m, line 52\u001B[39m\n\u001B[32m     50\u001B[39m \u001B[38;5;28mprint\u001B[39m(axis_path_1)\n\u001B[32m     51\u001B[39m \u001B[38;5;66;03m#axis_path_1 = r\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\data\\data20250718_alignment_tests\\20250718_113013_static_0\" #uncomment for specific path\u001B[39;00m\n\u001B[32m---> \u001B[39m\u001B[32m52\u001B[39m axis_data_file_path_1 = \u001B[43mmyu\u001B[49m\u001B[43m.\u001B[49m\u001B[43mfind_newest_dat_file\u001B[49m\u001B[43m(\u001B[49m\u001B[43maxis_path_1\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m     53\u001B[39m \u001B[38;5;28mprint\u001B[39m(axis_data_file_path_1)\n\u001B[32m     54\u001B[39m \u001B[38;5;66;03m#mf.analyze_repeatability(axis_data_file_path_1,1.1)\u001B[39;00m\n",
+      "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[4]\u001B[39m\u001B[32m, line 55\u001B[39m\n\u001B[32m     53\u001B[39m \u001B[38;5;28mprint\u001B[39m(axis_path_1)\n\u001B[32m     54\u001B[39m \u001B[38;5;66;03m#axis_path_1 = r\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\data\\data20250718_alignment_tests\\20250718_113013_static_0\" #uncomment for specific path\u001B[39;00m\n\u001B[32m---> \u001B[39m\u001B[32m55\u001B[39m axis_data_file_path_1 = \u001B[43mmyu\u001B[49m\u001B[43m.\u001B[49m\u001B[43mfind_newest_dat_file\u001B[49m\u001B[43m(\u001B[49m\u001B[43maxis_path_1\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m     56\u001B[39m \u001B[38;5;28mprint\u001B[39m(axis_data_file_path_1)\n\u001B[32m     59\u001B[39m \u001B[38;5;66;03m#mf.analyze_repeatability(axis_data_file_path_1,1.1)\u001B[39;00m\n",
       "\u001B[36mFile \u001B[39m\u001B[32m~\\Python_Projects\\StagePerformaceDocu\\Scripts\\myutility.py:22\u001B[39m, in \u001B[36mfind_newest_dat_file\u001B[39m\u001B[34m(folder)\u001B[39m\n\u001B[32m     21\u001B[39m \u001B[38;5;28;01mdef\u001B[39;00m\u001B[38;5;250m \u001B[39m\u001B[34mfind_newest_dat_file\u001B[39m(folder):\n\u001B[32m---> \u001B[39m\u001B[32m22\u001B[39m     dat_files = glob.glob(\u001B[43mos\u001B[49m\u001B[43m.\u001B[49m\u001B[43mpath\u001B[49m\u001B[43m.\u001B[49m\u001B[43mjoin\u001B[49m\u001B[43m(\u001B[49m\u001B[43mfolder\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[33;43m'\u001B[39;49m\u001B[33;43m*.dat\u001B[39;49m\u001B[33;43m'\u001B[39;49m\u001B[43m)\u001B[49m)\n\u001B[32m     23\u001B[39m     \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m dat_files:\n\u001B[32m     24\u001B[39m         \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mFileNotFoundError\u001B[39;00m(\u001B[33m\"\u001B[39m\u001B[33mNo .dat files found in the specified directory.\u001B[39m\u001B[33m\"\u001B[39m)\n",
       "\u001B[36mFile \u001B[39m\u001B[32m<frozen ntpath>:100\u001B[39m, in \u001B[36mjoin\u001B[39m\u001B[34m(path, *paths)\u001B[39m\n",
       "\u001B[31mTypeError\u001B[39m: expected str, bytes or os.PathLike object, not NoneType"
      ]
     }
    ],
-   "execution_count": 7
-  },
-  {
-   "cell_type": "code",
-   "id": "9f3a5361dcc6f7f7",
-   "metadata": {},
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from mpl_toolkits.axes_grid1 import Divider, Size\n",
-    "fig, (ax1, ax2) = plt.subplots(2, 1,figsize=(10, 6) )\n",
-    "\n",
-    "# The first items are for padding and the second items are for the Axes.\n",
-    "# sizes are in inch.\n",
-    "h = [Size.Fixed(1.0), Size.Fixed(4.5)]\n",
-    "v = [Size.Fixed(0.7), Size.Fixed(5.)]\n",
-    "\n",
-    "divider = Divider(fig, (0, 0, 1, 1), h, v, aspect=False)\n",
-    "# The width and height of the rectangle are ignored.\n",
-    "ax2.set_axes_locator(plt.FixedLocator([0.5, 1.5, 2.5, 3.5]))\n",
-    "ax1.set_axes_locator(plt.FixedLocator([0.5, 1.5, 2.5, 3.5]))\n",
-    "\n",
-    "ax1.plot([1, 2, 3], [1, 2, 3], 'k--')\n",
-    "ax1.plot([4, 5, 6], [4, 5, 6], 'k--')\n",
-    "plt.show()"
-   ],
-   "outputs": [],
-   "execution_count": null
-  },
-  {
-   "cell_type": "code",
-   "id": "a51da887d5028934",
-   "metadata": {},
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "from mpl_fill_cmap_between import fill_cmap_between, fill_cmap_between_x\n",
-    "\n",
-    "x = np.linspace(-10, 10, 50)\n",
-    "y = x**2 - 40\n",
-    "\n",
-    "fig = plt.figure(figsize=(4.8, 2.0))\n",
-    "ax = fig.add_subplot(111)\n",
-    "\n",
-    "fill_cmap_between(x, y * 0.1, 0, ax=ax, cmap=\"viridis\", kw_line_1=dict(color=\"k\"),\n",
-    "                  kw_line_2=dict(color=\"k\", lw=0.5))\n",
-    "ax.set_aspect(\"equal\")"
-   ],
-   "outputs": [],
-   "execution_count": null
+   "execution_count": 4
   }
  ],
  "metadata": {