diff --git a/docs/tutorials/ms_methods.ipynb b/docs/tutorials/ms_methods.ipynb
new file mode 100644
index 0000000..10065a4
--- /dev/null
+++ b/docs/tutorials/ms_methods.ipynb
@@ -0,0 +1,513 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Raw file metrics for method development with AlphaRaw\n",
+    "This notebook shows how alpharaw can be used to calculate usefull raw file metric for method development.\n",
+    "All Metrics are calculated directly for a set of Thermo raw files independent of identifications.\n",
+    "\n",
+    "## 1. Load the raw files\n",
+    "We will start by downloading for example raw files but users can provide their own in the same format."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from alpharaw import thermo\n",
+    "import tempfile\n",
+    "from alphabase.test_data_downloader import DataShareDownloader\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data will be downloaded to /var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k\n"
+     ]
+    }
+   ],
+   "source": [
+    "temp_folder = tempfile.TemporaryDirectory()\n",
+    "print(f\"Data will be downloaded to {temp_folder.name}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0% |                                                                        |\r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_05.raw does not yet exist\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100% |########################################################################|\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_05.raw successfully downloaded to /var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_05.raw\n",
+      "/var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_06.raw does not yet exist\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100% |########################################################################|\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_06.raw successfully downloaded to /var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_06.raw\n",
+      "/var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_02.raw does not yet exist\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100% |########################################################################|\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_02.raw successfully downloaded to /var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_02.raw\n",
+      "/var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_03.raw does not yet exist\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100% |########################################################################|\r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_03.raw successfully downloaded to /var/folders/l0/0518479j4gvcb4cyl20vmkrm0000gn/T/tmpvw6wyn1k/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_03.raw\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"\\noutput_path = [\\n    '/path/to/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_05.raw',\\n    '/path/to/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_06.raw',\\n    '/path/to/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_02.raw',\\n    '/path/to/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_03.raw',\\n]\\n\""
+      ]
+     },
+     "execution_count": 98,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "url_list = [\n",
+    "    'https://datashare.biochem.mpg.de/s/339jg5HtGrwLwDN/download?files=20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_05.raw',\n",
+    "    'https://datashare.biochem.mpg.de/s/339jg5HtGrwLwDN/download?files=20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_06.raw',\n",
+    "    'https://datashare.biochem.mpg.de/s/JwxcW4kp4Vxb57e/download?files=20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_02.raw',\n",
+    "    'https://datashare.biochem.mpg.de/s/JwxcW4kp4Vxb57e/download?files=20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_03.raw',\n",
+    "]\n",
+    "\n",
+    "output_path = []\n",
+    "\n",
+    "for url in url_list:\n",
+    "    output_path.append(DataShareDownloader(url, temp_folder.name).download())\n",
+    "\n",
+    "# Users want to set their own path to the thermo raw file\n",
+    "\"\"\"\n",
+    "output_path = [\n",
+    "    '/path/to/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_05.raw',\n",
+    "    '/path/to/20231017_OA2_TiHe_ADIAMA_HeLa_200ng_Evo011_21min_F-40_06.raw',\n",
+    "    '/path/to/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_02.raw',\n",
+    "    '/path/to/20230815_OA1_SoSt_SA_Whisper40_ADIAMA_HeLa_5ng_8Th14ms_FAIMS-40_1900V_noLoopCount_03.raw',\n",
+    "]\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Import files in AlphaRaw\n",
+    "We will import the files with alphaRaw so we can access the individual spectral"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "49it [00:17,  2.87it/s]\n",
+      "49it [00:17,  2.78it/s]\n",
+      "21it [00:08,  2.42it/s]\n",
+      "21it [00:08,  2.39it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "raw_file_list = []\n",
+    "\n",
+    "for file in output_path:\n",
+    "    auxiliary_items = ['injection_time','faims_cv']\n",
+    "    raw_file = thermo.ThermoRawData(auxiliary_items=auxiliary_items)\n",
+    "    raw_file.load_raw(file)\n",
+    "    raw_file_list.append(raw_file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Define Metrics\n",
+    "Define metrics to be calculated on the raw files. Each metric is a single function which is called on the raw file list."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def shorten_file_name(file_name: str, chars: int = 10) -> str:\n",
+    "    \"\"\"Shorten the file name to the first and last chars separated by ...\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "        file_name : str\n",
+    "            File name to shorten\n",
+    "\n",
+    "        chars : int, optional\n",
+    "            Number of characters to keep at the start and end of the file name, by default 10\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "        str\n",
+    "            Shortened file name\n",
+    "\n",
+    "    \"\"\"\n",
+    "    return file_name[:chars] + '...' + file_name[-chars:]\n",
+    "\n",
+    "def ms2_injection_time(raw_file_list: list[thermo.ThermoRawData]):\n",
+    "    \"\"\"Plot the MS2 injection time for each file in the list of raw files.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "        raw_file_list : list[thermo.ThermoRawData]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # accumulate ms2 injection time\n",
+    "    _stat_df = []\n",
+    "    for raw_file in raw_file_list:\n",
+    "        file_name = os.path.basename(raw_file._raw_file_path)\n",
+    "\n",
+    "        for ms_level in raw_file.spectrum_df['ms_level'].unique():\n",
+    "    \n",
+    "            _local_stat_df = raw_file.spectrum_df[raw_file.spectrum_df['ms_level'] == ms_level][['spec_idx','injection_time','ms_level']]\n",
+    "            _local_stat_df = _local_stat_df.rename(columns={'injection_time':'ms2_injection_time'})\n",
+    "            _local_stat_df['file_name'] = shorten_file_name(file_name)\n",
+    "\n",
+    "            _stat_df.append(_local_stat_df)\n",
+    "\n",
+    "    _stat_df = pd.concat(_stat_df)\n",
+    "\n",
+    "    #plotting\n",
+    "    fig, ax = plt.subplots()\n",
+    "    sns.boxplot(x='file_name', y='ms2_injection_time', hue='ms_level', data=_stat_df, ax=ax, palette='Set1', fill=False)\n",
+    "    ax.set_title('Injection time')\n",
+    "    ax.set_ylabel('Injection time (ms)')\n",
+    "    ax.set_xlabel('File name')\n",
+    "    # 90 degree rotation of x-axis labels\n",
+    "    plt.xticks(rotation=90)\n",
+    "    plt.show()\n",
+    "\n",
+    "def gradient_length(raw_file_list: list[thermo.ThermoRawData]):\n",
+    "    \"\"\"Plot the gradient length for each file in the list of raw files.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "        raw_file_list : list[thermo.ThermoRawData]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # accumulate gradient length\n",
+    "    _stat_df = []\n",
+    "    for raw_file in raw_file_list:\n",
+    "        file_name = os.path.basename(raw_file._raw_file_path)\n",
+    "\n",
+    "        _delta_rt = raw_file.spectrum_df['rt'].max() - raw_file.spectrum_df['rt'].min()\n",
+    "        _stat_df.append({'file_name': shorten_file_name(file_name), 'gradient_length': _delta_rt})\n",
+    "\n",
+    "    _stat_df = pd.DataFrame(_stat_df)\n",
+    "\n",
+    "    #plotting\n",
+    "    fig, ax = plt.subplots()\n",
+    "    sns.barplot(x='file_name', y='gradient_length', data=_stat_df, ax=ax)\n",
+    "    ax.set_title('Gradient length')\n",
+    "    ax.set_ylabel('Gradient length (min)')\n",
+    "    ax.set_xlabel('File name')\n",
+    "    # 90 degree rotation of x-axis labels\n",
+    "    plt.xticks(rotation=90)\n",
+    "    plt.show()\n",
+    "\n",
+    "def ms_range(raw_file_list: list[thermo.ThermoRawData]):\n",
+    "    \"\"\"Plot all ms2 scans for each file in the list of raw files.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "        raw_file_list : list[thermo.ThermoRawData]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # accumulate gradient length\n",
+    "    _stat_df = []\n",
+    "    for raw_file in raw_file_list:\n",
+    "        file_name = os.path.basename(raw_file._raw_file_path)\n",
+    "\n",
+    "        ms2_scans = raw_file.spectrum_df[raw_file.spectrum_df['ms_level'] == 2]['precursor_mz'].unique()\n",
+    "        _local_stat_df = pd.DataFrame({'file_name': shorten_file_name(file_name), 'ms2_scans': ms2_scans})\n",
+    "        _stat_df.append(_local_stat_df)\n",
+    "\n",
+    "    _stat_df = pd.concat(_stat_df)\n",
+    "\n",
+    "    #plotting\n",
+    "    fig, ax = plt.subplots()\n",
+    "    sns.scatterplot(x='file_name', y='ms2_scans', data=_stat_df, ax=ax)\n",
+    "    ax.set_title('MS2 Range')\n",
+    "    ax.set_ylabel('m/z')\n",
+    "    ax.set_xlabel('File name')\n",
+    "\n",
+    "    ax.set_ylim([0, ax.get_ylim()[1]])\n",
+    "    # 90 degree rotation of x-axis labels\n",
+    "    plt.xticks(rotation=90)\n",
+    "    plt.show()\n",
+    "\n",
+    "def ms_scan_num(raw_file_list: list[thermo.ThermoRawData]):\n",
+    "    \"\"\"Plot all ms2 scans for each file in the list of raw files.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "        raw_file_list : list[thermo.ThermoRawData]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # accumulate gradient length\n",
+    "    _stat_df = []\n",
+    "    for raw_file in raw_file_list:\n",
+    "        file_name = os.path.basename(raw_file._raw_file_path)\n",
+    "\n",
+    "        ms2_scans = raw_file.spectrum_df[raw_file.spectrum_df['ms_level'] == 2]['precursor_mz'].nunique()\n",
+    "        _local_stat_df = pd.DataFrame([{'file_name': shorten_file_name(file_name), 'ms2_scans': ms2_scans}])\n",
+    "        _stat_df.append(_local_stat_df)\n",
+    "\n",
+    "    _stat_df = pd.concat(_stat_df)\n",
+    "\n",
+    "    #plotting\n",
+    "    fig, ax = plt.subplots()\n",
+    "    sns.barplot(x='file_name', y='ms2_scans', data=_stat_df, ax=ax)\n",
+    "    ax.set_title('Number of MS2 scans')\n",
+    "    ax.set_ylabel('# Scans')\n",
+    "    ax.set_xlabel('File name')\n",
+    "\n",
+    "    ax.set_ylim([0, ax.get_ylim()[1]])\n",
+    "    # 90 degree rotation of x-axis labels\n",
+    "    plt.xticks(rotation=90)\n",
+    "    plt.show()\n",
+    "\n",
+    "def _tic_for_spectrum_df(spectrum_df: pd.DataFrame, peak_df: pd.DataFrame) -> pd.DataFrame:\n",
+    "    \"\"\"Calculate the TIC for each spectrum in the spectrum_df.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "\n",
+    "        spectrum_df : pd.DataFrame\n",
+    "            Spectrum DataFrame\n",
+    "\n",
+    "        peak_df : pd.DataFrame\n",
+    "            Peak DataFrame\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "        pd.DataFrame\n",
+    "            DataFrame with the TIC for each spectrum\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    _stat_df = []\n",
+    "    for spec_idx, peak_start_idx, peak_stop_idx in zip(spectrum_df['spec_idx'], spectrum_df['peak_start_idx'], spectrum_df['peak_stop_idx']):\n",
+    "        _stat_df.append({'spec_idx': spec_idx, 'tic': peak_df.iloc[peak_start_idx:peak_stop_idx]['intensity'].sum()})\n",
+    "\n",
+    "    return pd.DataFrame(_stat_df)\n",
+    "\n",
+    "\n",
+    "def tic_distribution(raw_file_list: list[thermo.ThermoRawData]):\n",
+    "    \"\"\"Plot the gradient length for each file in the list of raw files.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "        raw_file_list : list[thermo.ThermoRawData]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # accumulate gradient length\n",
+    "    _stat_df = []\n",
+    "    for raw_file in raw_file_list:\n",
+    "        file_name = os.path.basename(raw_file._raw_file_path)\n",
+    "\n",
+    "        for ms_level in raw_file.spectrum_df['ms_level'].unique():      \n",
+    "            _local_stat_df = _tic_for_spectrum_df(raw_file.spectrum_df[raw_file.spectrum_df['ms_level'] == ms_level], raw_file.peak_df)\n",
+    "            _local_stat_df['file_name'] = shorten_file_name(file_name)\n",
+    "            _local_stat_df['ms_level'] = ms_level\n",
+    "\n",
+    "            _stat_df.append(_local_stat_df)\n",
+    "\n",
+    "    _stat_df = pd.concat(_stat_df).reset_index(drop=True)\n",
+    "\n",
+    "    _stat_df['log_10_tic'] = np.log10(_stat_df['tic'])\n",
+    "\n",
+    "    #plotting\n",
+    "    fig, ax = plt.subplots()\n",
+    "    sns.boxplot(x='file_name', y='log_10_tic', hue='ms_level', data=_stat_df, ax=ax, palette='Set1', fill=False)\n",
+    "    ax.set_title('TIC distribution')\n",
+    "    ax.set_ylabel('log10(TIC)')\n",
+    "    ax.set_xlabel('File name')\n",
+    "    # 90 degree rotation of x-axis labels\n",
+    "    plt.xticks(rotation=90)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Calculate and plot metrics\n",
+    "We can now calculate and plot the individual metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for metric in [ms2_injection_time, gradient_length, ms_range, ms_scan_num, tic_distribution]:\n",
+    "    metric(raw_file_list)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "alpha",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}