diff --git a/600A/AN_600A_PNO.d3.ipynb b/600A/AN_600A_PNO.d3.ipynb
index f8fd8c4010cbe99dbb14e1abc91ce1914403f2dc..7143315ae8dacb61d071b0a53923bad23c7b3923 100644
--- a/600A/AN_600A_PNO.d3.ipynb
+++ b/600A/AN_600A_PNO.d3.ipynb
@@ -52,7 +52,7 @@
     "from matplotlib import pyplot as plt\n",
     "\n",
     "import lhcsmapi\n",
-    "from lhcsmapi.gui.hwc.HwcSearchModuleMediator import HwcSearchModuleMediator\n",
+    "from lhcsmapi import reference\n",
     "from lhcsmapi.Time import Time\n",
     "from lhcsmapi.api import query\n",
     "from lhcsmapi.api.analysis import powering\n",
@@ -111,14 +111,11 @@
    },
    "outputs": [],
    "source": [
-    "t_start = Time.to_unix_timestamp(t_start)\n",
-    "t_end = Time.to_unix_timestamp(t_end)\n",
-    "summary_file = \"/eos/project/l/lhcsm/hwc/HWC_Summary.csv\"\n",
-    "t_start_ref, t_end_ref = HwcSearchModuleMediator.get_last_ref_start_end_time(\n",
-    "    summary_file, circuit_name, hwc_test, Time.to_string_short(t_start)\n",
-    ")\n",
-    "t_start_ref, t_end_ref = Time.to_unix_timestamp(t_start_ref), Time.to_unix_timestamp(t_end_ref)\n",
-    "test_parameters = powering.TestParameterInputWithRef(\n",
+    "hwc_summary = signal_metadata.get_hwc_summary()\n",
+    "strategy = powering.get_reference_test_selection_strategy(hwc_test)\n",
+    "t_start_ref, t_end_ref = reference.get_reference_test(hwc_summary, circuit_name, hwc_test, t_start, strategy)\n",
+    "\n",
+    "test_parameters = powering.TestParameterInputWithRef.create(\n",
     "    hwc_test, circuit_name, campaign, t_start, t_end, t_start_ref, t_end_ref\n",
     ")\n",
     "print(test_parameters)"
@@ -416,9 +413,11 @@
     "analysis_start_time = Time.get_analysis_start_time()\n",
     "# signature = 'SIGNATURE'\n",
     "report_destination_path = report_destination_path_template.format(\n",
-    "    signal_metadata.get_family_name_for_600A(circuit_name), circuit_name\n",
+    "    signal_metadata.get_family_name_for_600A(test_parameters.circuit_name), test_parameters.circuit_name\n",
+    ")\n",
+    "report_filename = report_filename_template.format(\n",
+    "    test_parameters.circuit_name, test_parameters.hwc_test, test_parameters.t_start, analysis_start_time, signature\n",
     ")\n",
-    "report_filename = report_filename_template.format(circuit_name, hwc_test, t_start, analysis_start_time, signature)\n",
     "\n",
     "!mkdir -p $report_destination_path\n",
     "\n",
diff --git a/ipq/AN_IPQ_PLI2.e3.ipynb b/ipq/AN_IPQ_PLI2.e3.ipynb
index 5d96c4ada1a42695992172d845e10205131d1c56..cab102e8dc276d116123ef5e643417c5b65de6a6 100644
--- a/ipq/AN_IPQ_PLI2.e3.ipynb
+++ b/ipq/AN_IPQ_PLI2.e3.ipynb
@@ -11,77 +11,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "deletable": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "# PLI2.e3 - UNBALANCED SLOW POWER ABORT\n",
-       "\n",
-       "Circuit: IPQ\n",
-       "\n",
-       "## Introduction \n",
-       "\n",
-       "The purpose of this test is to verify the response of both power converters in case of a Slow Power Abort (SPA) with unbalanced currents. During the test, the current (I_MEAS) is both apertures is increased to a certain level (which depends on circuit) and in different number of steps. Afterwards, the SPA is triggered - power converters (PC) are in state \"SLOW_ABORT\". \n",
-       "\n",
-       "\n",
-       "The first check includes verifying that the SPA took place and that there was no trip of the Quench Protection System (QPS). The latter condition is ensured when (i) no Post Mortem (PM) data has been created by the Quench Protection System (QPS) during the entire test and (ii) no PM data has been created by Function Generator Controllers (FGC) from the start of the test until the current decay up to I_MIN_OP = 100 A for B1. The plateau consistency check involves assessments that duration of the 3rd plateu (at the highest current level) for B1 is more than 300 s (TIME_TOP) and the flattop level is 1% w.r.t. reference value (*), both for B1 and B2. In the next check, the maximum absolute value of the ramp-rate and acceleration are compared with the reference signal. The power converter status check is performed to validate that power converters are turned off after current decays (status \"FLT_OFF\").\n",
-       "The last check involves evaluating temperature regulation of the Distribution Feed Box (DFB). It must be ensured that the temperature TT891A at the top of the HTS part of each of the three current leads and the temperature TT893 at the top of the copper part of each of the three current leads are within the specified range.\n",
-       "\n",
-       "\n",
-       "\n",
-       "## MP3 Analysis\n",
-       "\n",
-       "The MP3 Analysis of PLI2.e3 test consists of 5 assessments: \n",
-       "\n",
-       "\n",
-       "1. PM buffers absence and timestamps check\n",
-       "    - **2 x SPA** (STATE is SLOW_ABORT for B1 and B2);\n",
-       "    - SPA for B1 and B2 are within **±40ms**;\n",
-       "    - 0 x QPS PM (during the entire test) and 0 x FGC PM (from test start until the current in one of the Power Converter decays down to I_MIN_OP = 100 A);   \n",
-       "\n",
-       "2.  Current profile consistency check\n",
-       "    - Duration of the 3rd plateau (at the highest current level) for B1 is more than **300 s**;\n",
-       "    - Flattop current level is within **1%** w.r.t. reference value (*) for B1 and B2;\n",
-       "\n",
-       "   Input parameters in _calculate_plateau_duration_and_level()_: _plateau_end_ts = timestamp_{b1,b1_ref,b2,b2_ref}_end_relative, _plateau_min_duration_sec_, _delta_. In particular, the values of _plateau_min_duration_sec_ and _delta_ are found experimentally. For references: _plateau_min_duration_sec_  = 70, _delta_ = 0.5. For analyzed signals: _plateau_min_duration_sec_ = 1, _delta_  = 0.5. \n",
-       "\n",
-       "3. Ramp-rate and acceleration check\n",
-       "    - The absolute value of the maximum ramp-rate before the SPA is within **0.5%** w.r.t. reference (*) value, both for B1 and B2;\n",
-       "    - The absolute value of the maximum acceleration before the SPA is within **0.5%** w.r.t. reference (*) value, both for B1 and B2;\n",
-       "\n",
-       "4. Power converter status check\n",
-       "    - Power converters are in **FLT_OFF** state after the SPA;\n",
-       "\n",
-       "5. DFB regulation check\n",
-       "    - Temperature TT891A at the top of the HTS part of each of the three current leads ranges **from 46 K to 54 K**, even at 0 A;\n",
-       "    - Temperature TT893 at the top of the copper part of each of the three current leads ranges **from 280 K to 320 K**, even at 0 A;  \n",
-       "\n",
-       "\n",
-       "(*) The reference signal is the last successful PLI2.e3 test or STEAM simulation.\n",
-       "\n",
-       "Remark: All events with heater-firing at I>400 A will later be analysed using the FAST POWER ABORT (FPA) notebook and the results will be stored in the quench database. \n",
-       "\n",
-       "Note: In future, it is envisaged that minimum operating current, plateau duration, average current at plateau for B1 and B2, ramp-rate and acceleration will be compared with corresponding parameter values stored in the Accelerator Test Tracking (I_MIN_OP, TIME_TOP, I_INTERM_1, I_INTERM_2, DIDT_PNO, ACC_PNO). \n",
-       "\n",
-       "\n",
-       "\n",
-       "## Source\n",
-       "1. _Test Procedure for the Individually Powered 4-6 kA Quadrupole-Circuits in the LHC Insertions_, EDMS 874884 v.4.0, https://edms.cern.ch/document/874884/4.0 .\n",
-       "2. _Quench Database_, MP3 Twiki, https://twiki.cern.ch/twiki/bin/view/MP3/QuenchDatabase\n",
-       "\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from __future__ import annotations\n",
     "\n",
@@ -95,18 +29,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Analysis executed with lhc-sm-api version: 1.7.0\n",
-      "Analysis performed by amurariu\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import getpass\n",
     "import logging\n",
@@ -126,7 +51,8 @@
     ")\n",
     "from lhcsmapi.analysis.expert_input import get_expert_decision\n",
     "from lhcsmapi.Time import Time\n",
-    "from lhcsmapi.gui.hwc.HwcSearchModuleMediator import HwcSearchModuleMediator\n",
+    "from lhcsmapi.metadata import signal_metadata\n",
+    "from lhcsmapi import reference\n",
     "\n",
     "%xmode Minimal\n",
     "logging.getLogger().setLevel(logging.INFO)\n",
@@ -139,45 +65,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ENVIRONMENT:\n",
-      "NXCALS_VERSION=1.4.11\n",
-      "VIRTUAL_ENV=/home/amurariu/Documents/repos/venv_9\n",
-      "SPARK_HOME=/home/amurariu/Documents/repos/venv_9/nxcals-bundle\n",
-      "SPARK_CONF_DIR=/tmp/nxcals-eb6d2bcdead658e3d45dd54e2dec5fa9/conf\n",
-      "SPARK_DEFAULTS=/home/amurariu/Documents/repos/venv_9/nxcals-bundle/conf/spark-defaults.conf\n",
-      "NXCALS_WORKSPACE_TEMP_DIR=/tmp/nxcals-eb6d2bcdead658e3d45dd54e2dec5fa9\n",
-      "PACKED_VENV_FILE=/tmp/nxcals-eb6d2bcdead658e3d45dd54e2dec5fa9/nxcals-python3-env.tar.gz\n",
-      "PYSPARK_PYTHON=/home/amurariu/Documents/repos/venv_9/bin/python\n",
-      "PYSPARK_DRIVER_PYTHON=/home/amurariu/Documents/repos/venv_9/bin/python\n",
-      "PYSPARK_DRIVER_PYTHON_OPTS=\n",
-      "\n",
-      "IMPORTANT:\n",
-      "Rebuilding of the packed venv is required in cases there are new or modified packages provided by a user. In order to recreate the packed venv please:\n",
-      "        - remove the file (rm /tmp/nxcals-eb6d2bcdead658e3d45dd54e2dec5fa9/nxcals-python3-env.tar.gz)\n",
-      "        - execute your script again (rebuild will be performed during the startup of PySpark/Python)\n",
-      "Target directory can be set with an env variable NXCALS_WORKSPACE_TEMP_DIR (if not set a temp dir will be used).\n",
-      "Adding NXCALS related files to packed venv can be enabled by setting NXCALS_PACK_ALL_PACKAGES with any value.\n",
-      "Trying to determine YARN usage to make Python work correctly (conf/spark-env.sh)...\n",
-      "Not using YARN\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "24/03/26 16:34:25 WARN Utils: Your hostname, amurariu-HP-EliteDesk-800-G2-TWR resolves to a loopback address: 127.0.1.1; using 128.141.191.10 instead (on interface eno1)\n",
-      "24/03/26 16:34:25 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n",
-      "24/03/26 16:34:27 WARN Utils: Service 'SparkUI' could not bind on port 5201. Attempting port 5202.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "if \"spark\" not in locals() and \"spark\" not in globals():\n",
     "    from nxcals.spark_session_builder import get_or_create\n",
@@ -197,7 +87,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "deletable": false,
     "tags": [
@@ -215,35 +105,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "hwc_test: PLI2.e3\n",
-      "circuit name: RQ9.R6\n",
-      "campain: Recommissioning post LS2\n",
-      "t_start: 1625171258736000000 (2021-07-01 22:27:38.736)\n",
-      "t_end: 1625172937241000000 (2021-07-01 22:55:37.241)\n",
-      "t_start_ref: 1425318486476000000 (2015-03-02 18:48:06.476)\n",
-      "t_end_ref: 1425320066764000000 (2015-03-02 19:14:26.764)\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Find the reference as a last successfull test\n",
-    "t_start = Time.to_unix_timestamp(t_start)\n",
-    "t_end = Time.to_unix_timestamp(t_end)\n",
-    "summary_file = \"/eos/project/l/lhcsm/hwc/HWC_Summary.csv\"\n",
-    "t_start_ref, t_end_ref = HwcSearchModuleMediator.get_last_ref_start_end_time(\n",
-    "    summary_file, circuit_name, hwc_test, Time.to_string_short(t_start)\n",
-    ")\n",
+    "hwc_summary = signal_metadata.get_hwc_summary()\n",
+    "strategy = powering.get_reference_test_selection_strategy(hwc_test)\n",
+    "t_start_ref, t_end_ref = reference.get_reference_test(hwc_summary, circuit_name, hwc_test, t_start, strategy)\n",
     "\n",
-    "t_start_ref, t_end_ref = Time.to_unix_timestamp(t_start_ref), Time.to_unix_timestamp(t_end_ref)\n",
-    "test_parameters = powering.TestParameterInputWithRef(\n",
+    "test_parameters = powering.TestParameterInputWithRef.create(\n",
     "    hwc_test, circuit_name, campaign, t_start, t_end, t_start_ref, t_end_ref\n",
     ")\n",
     "print(test_parameters)"
@@ -258,44 +129,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Circuits test parameters:\n",
-      "\tRPHGA.UJ67.RQ9.R6B1\n",
-      "\t\tL_TOT = 0.026 H\n",
-      "\t\tR_TOT_MEASURED = 0.000389 Ω\n",
-      "\tRPHGA.UJ67.RQ9.R6B2\n",
-      "\t\tL_TOT = 0.026 H\n",
-      "\t\tR_TOT_MEASURED = 0.000424 Ω\n",
-      "\n",
-      "\n",
-      "Powering test parameters:\n",
-      "\tRPHGA.UJ67.RQ9.R6B1\n",
-      "\t\tI_MIN_OP = 100.0 A\n",
-      "\t\tI_INJECTION = 253.0 A\n",
-      "\t\tI_INTERM_1 = 1600.0 A\n",
-      "\t\tI_INTERM_2 = 2900.0 A\n",
-      "\t\tDIDT_PNO = 16.167 A/s\n",
-      "\t\tACC_PNO = 2.0 A/s²\n",
-      "\t\tTIME_ZERO = 60.0 s\n",
-      "\t\tTIME_TOP = 300.0 s\n",
-      "\tRPHGA.UJ67.RQ9.R6B2\n",
-      "\t\tI_MIN_OP = 100.0 A\n",
-      "\t\tI_INJECTION = 253.0 A\n",
-      "\t\tI_INTERM_1 = 1600.0 A\n",
-      "\t\tI_INTERM_2 = 2900.0 A\n",
-      "\t\tDIDT_PNO = 16.167 A/s\n",
-      "\t\tACC_PNO = 2.0 A/s²\n",
-      "\t\tTIME_ZERO = 60.0 s\n",
-      "\t\tTIME_TOP = 300.0 s\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "hwc_powering_test_parameters = query.query_hwc_powering_test_parameters(\n",
     "    test_parameters.circuit_name, test_parameters.t_start, test_parameters.t_end - test_parameters.t_start\n",
@@ -320,7 +156,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "deleteable": false,
     "tags": [
@@ -335,87 +171,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n",
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n",
-      "[Stage 15:==================================================>       (7 + 1) / 8]\r"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "RPHGA.UJ67.RQ9.R6B1 enters SLOW_ABORT at 1625172542080000000.\n",
-      "RPHGA.UJ67.RQ9.R6B2 enters SLOW_ABORT at 1625172542080000000.\n",
-      "RPHGA.UJ67.RQ9.R6B1 enters SLOW_ABORT at 1425319772000000000.\n",
-      "RPHGA.UJ67.RQ9.R6B2 enters SLOW_ABORT at 1425319772000000000.\n",
-      "RPHGA.UJ67.RQ9.R6B1 enters FLT_OFF at 1625172799080000000.\n",
-      "RPHGA.UJ67.RQ9.R6B2 enters FLT_OFF at 1625172798580000000.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n",
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n",
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n",
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n",
-      "[Stage 47:==================================================>       (7 + 1) / 8]\r"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "FGC PM data dumps ('FGC', lhc_self_pmd, RPHGA.UJ67.RQ9.R6B1) and ('FGC', lhc_self_pmd, RPHGA.UJ67.RQ9.R6B2) queried between 1625171258736000000 and 1625172798080000000.\n",
-      "QPS PM data dumps queried between 1625171258736000000 and 1625172937241000000.\n",
-      "Found following QPS dumps: Empty DataFrame\n",
-      "Columns: [source, timestamp]\n",
-      "Index: []\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Post Mortem returned no data for the following query: http://pm-rest.cern.ch/v2//pmdata/header/within/duration?system=FGC&className=lhc_self_pmd&source=RPHGA.UJ67.RQ9.R6B1&fromTimestampInNanos=1625171258736000000&durationInNanos=1539344000000\n",
-      "Post Mortem returned no data for the following query: http://pm-rest.cern.ch/v2//pmdata/header/within/duration?system=FGC&className=lhc_self_pmd&source=RPHGA.UJ67.RQ9.R6B2&fromTimestampInNanos=1625171258736000000&durationInNanos=1539344000000\n",
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n",
-      "toPandas attempted Arrow optimization because 'spark.sql.execution.arrow.pyspark.enabled' is set to true; however, failed by the reason below:\n",
-      "  PyArrow >= 4.0.0 must be installed; however, it was not found.\n",
-      "Attempting non-optimization as 'spark.sql.execution.arrow.pyspark.fallback.enabled' is set to true.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 803 ms, sys: 31.5 ms, total: 834 ms\n",
-      "Wall time: 40.3 s\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%time\n",
     "analysis_class.query()"
@@ -423,35 +181,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Check passed: SLOW POWER ABORT on PC B1 and PC B2 occured within 40000000000 ns.\n",
-      "Check passed: No QPS PM data dump found.\n",
-      "Check passed: No FGC PM data dump found.\n",
-      "Check passed: Both duration and level for PC b1 of the I_MEAS plateau are consistent with the reference. Plateau duration is 696.500000 s, the flattop current is 2900.000000 what is consistent with reference duration 641.000000 s and reference current 2900.000000.\n",
-      "Check passed: Both duration and level for PC b2 of the I_MEAS plateau are consistent with the reference. Plateau duration is 301.000000 s, the flattop current is 1600.000000 what is consistent with reference duration 288.000000 s and reference current 1599.998333.\n",
-      "Check passed: Ramp rate is consistent with the reference for beam B1.\n",
-      "Relative ramp rate error of 1.6418% is larger than 0.5000% for beam B2.\n",
-      "Check passed: Acceleration is consistent with the reference for beam B1.\n",
-      "Check passed: Acceleration is consistent with the reference for beam B2.\n",
-      "Check passed: SLOW POWER ABORT happened before FLT_OFF for beam B1.\n",
-      "Check passed: SLOW POWER ABORT happened before FLT_OFF for beam B2.\n",
-      "Check passed: DFB DALC04_05R6_TT891A.TEMPERATURECALC temperature is in range [46.000000, 54.000000]\n",
-      "Check passed: DFB DALC05_05R6_TT891A.TEMPERATURECALC temperature is in range [46.000000, 54.000000]\n",
-      "Check passed: DFB DALC06_05R6_TT891A.TEMPERATURECALC temperature is in range [46.000000, 54.000000]\n",
-      "Check passed: DFB DALC04_05R6_TT893.TEMPERATURECALC temperature is in range [280.000000, 320.000000]\n",
-      "Check passed: DFB DALC05_05R6_TT893.TEMPERATURECALC temperature is in range [280.000000, 320.000000]\n",
-      "Check passed: DFB DALC06_05R6_TT893.TEMPERATURECALC temperature is in range [280.000000, 320.000000]\n",
-      "CPU times: user 39.3 ms, sys: 7.84 ms, total: 47.1 ms\n",
-      "Wall time: 43.2 ms\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%time\n",
     "analysis_class.analyze()"
@@ -459,17 +191,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The automated analysis result is \u001b[1mFailed\u001b[0m\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "analysis_result = \"Passed\" if analysis_class.get_analysis_output() else \"Failed\"\n",
     "print(f\"The automated analysis result is \\033[1m{analysis_result}\\033[0m\")"
@@ -486,42 +210,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "deletable": false,
     "scrolled": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "FGC B1 dumps: Empty DataFrame\n",
-      "Columns: [source, timestamp]\n",
-      "Index: []\n",
-      "FGC B2 dumps: Empty DataFrame\n",
-      "Columns: [source, timestamp]\n",
-      "Index: []\n",
-      "QPS dumps: Empty DataFrame\n",
-      "Columns: [source, timestamp]\n",
-      "Index: []\n",
-      "\n",
-      "Timestamp check: True\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 398, \"Check passed: SLOW POWER ABORT on PC B1 and PC B2 occured within %d ns.\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 421, \"Check passed: No QPS PM data dump found.\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 446, \"Check passed: No FGC PM data dump found.\">]"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(f\"FGC B1 dumps: {analysis_class.get_result('fgc_b1_dumps')}\")\n",
     "print(f\"FGC B2 dumps: {analysis_class.get_result('fgc_b2_dumps')}\")\n",
@@ -540,38 +234,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Current profile consistency check: True\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 574, \"Check passed: Both duration and level for PC %s of the I_MEAS plateau are consistent with the reference. Plateau duration is %f s, the flattop current is %f what is consistent with reference duration %f s and reference current %f.\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 574, \"Check passed: Both duration and level for PC %s of the I_MEAS plateau are consistent with the reference. Plateau duration is %f s, the flattop current is %f what is consistent with reference duration %f s and reference current %f.\">]"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%matplotlib widget\n",
     "i_meas_b1_df: pd.DataFrame = analysis_class.get_result(\"i_meas_b1_df\")\n",
@@ -587,7 +252,8 @@
     "ax.set_xlabel(\"Time, [s]\")\n",
     "ax.set_ylabel(\"I_MEAS, [A]\")\n",
     "ax.set_title(\n",
-    "    f\"{circuit_name}, {hwc_test}, t0 = {Time.to_string(t_start)[0:23]}, t0_REF = {Time.to_string(t_start_ref)[0:23]}\"\n",
+    "    f\"{test_parameters.circuit_name}, {test_parameters.hwc_test}, \"\n",
+    "    f\"t0 = {Time.to_string(test_parameters.t_start)[0:23]}, t0_REF = {Time.to_string(test_parameters.t_start_ref)[0:23]}\"\n",
     ")\n",
     "ax.grid(True)\n",
     "ax.legend([\"I_MEAS_B1\", \"I_MEAS_B1_REF\", \"I_MEAS_B2\", \"I_MEAS_B2_REF\"])\n",
@@ -607,38 +273,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ramp rate check: False\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 651, \"Check passed: Ramp rate is consistent with the reference for beam B1.\">,\n",
-       " <LogRecord: root, 40, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 644, \"Relative ramp rate error of 1.6418% is larger than 0.5000% for beam B2.\">]"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%matplotlib widget\n",
     "i_meas_b1_df: pd.DataFrame = analysis_class.get_result(\"i_meas_b1_df\")\n",
@@ -650,7 +287,8 @@
     "\n",
     "fig, (ax0, ax1, ax2) = plt.subplots(3, 1, figsize=(10, 12), sharex=True)\n",
     "fig.suptitle(\n",
-    "    f\"{circuit_name}, {hwc_test}, t0 = {Time.to_string(t_start)[0:23]}, t0_REF = {Time.to_string(t_start_ref)[0:23]}\"\n",
+    "    f\"{test_parameters.circuit_name}, {test_parameters.hwc_test}, \"\n",
+    "    f\"t0 = {Time.to_string(test_parameters.t_start)[0:23]}, t0_REF = {Time.to_string(test_parameters.t_start_ref)[0:23]}\"\n",
     ")\n",
     "\n",
     "i_meas_b1_df.plot(ax=ax0, marker=\".\")\n",
@@ -679,38 +317,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ramp acceleration check: True\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 686, \"Check passed: Acceleration is consistent with the reference for beam B1.\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 686, \"Check passed: Acceleration is consistent with the reference for beam B2.\">]"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%matplotlib widget\n",
     "\n",
@@ -723,7 +332,8 @@
     "\n",
     "fig, (ax0, ax1, ax2) = plt.subplots(3, 1, figsize=(10, 12), sharex=True)\n",
     "fig.suptitle(\n",
-    "    f\"{circuit_name}, {hwc_test}, t0 = {Time.to_string(t_start)[0:23]}, t0_REF = {Time.to_string(t_start_ref)[0:23]}\"\n",
+    "    f\"{test_parameters.circuit_name}, {test_parameters.hwc_test}, \"\n",
+    "    f\"t0 = {Time.to_string(test_parameters.t_start)[0:23]}, t0_REF = {Time.to_string(test_parameters.t_start_ref)[0:23]}\"\n",
     ")\n",
     "\n",
     "i_meas_b2_df.plot(ax=ax0, marker=\".\")\n",
@@ -759,80 +369,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>Source</th>\n",
-       "      <th>Timestamp</th>\n",
-       "      <th>Date and time</th>\n",
-       "      <th>dt w.r.t. origin [ms]</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>SPA_B1</td>\n",
-       "      <td>1625172542080000000</td>\n",
-       "      <td>2021-07-01 22:49:02.080</td>\n",
-       "      <td>0.0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>SPA_B2</td>\n",
-       "      <td>1625172542080000000</td>\n",
-       "      <td>2021-07-01 22:49:02.080</td>\n",
-       "      <td>0.0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>FLT_B2</td>\n",
-       "      <td>1625172798580000000</td>\n",
-       "      <td>2021-07-01 22:53:18.580</td>\n",
-       "      <td>256500.0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>FLT_B1</td>\n",
-       "      <td>1625172799080000000</td>\n",
-       "      <td>2021-07-01 22:53:19.080</td>\n",
-       "      <td>257000.0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Power converter status check: True\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 484, \"Check passed: SLOW POWER ABORT happened before FLT_OFF for beam %s.\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 484, \"Check passed: SLOW POWER ABORT happened before FLT_OFF for beam %s.\">]"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "timestamp_dct = {\n",
     "    \"SPA_B1\": analysis_class.get_result(\"timestamp_spa_b1\"),\n",
@@ -857,44 +396,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {
     "deletable": false
    },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1500x1000 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "DFB regulation check: True\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 711, \"Check passed: DFB %s temperature is in range [%f, %f]\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 711, \"Check passed: DFB %s temperature is in range [%f, %f]\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 711, \"Check passed: DFB %s temperature is in range [%f, %f]\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 711, \"Check passed: DFB %s temperature is in range [%f, %f]\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 711, \"Check passed: DFB %s temperature is in range [%f, %f]\">,\n",
-       " <LogRecord: root, 20, /home/amurariu/Documents/repos/venv_9/lib/python3.9/site-packages/lhcsmapi/api/analysis/powering/pli2_e3/__init__.py, 711, \"Check passed: DFB %s temperature is in range [%f, %f]\">]"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%matplotlib widget\n",
     "dacc01_tt891a_df: pd.DataFrame = analysis_class.get_result(\"dacc01_tt891a_df\")\n",
@@ -906,7 +412,8 @@
     "\n",
     "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 10))\n",
     "fig.suptitle(\n",
-    "    f\"{circuit_name}, {hwc_test}, t0 = {Time.to_string(t_start)[0:23]}, t0_REF = {Time.to_string(t_start_ref)[0:23]}\"\n",
+    "    f\"{test_parameters.circuit_name}, {test_parameters.hwc_test} ,\"\n",
+    "    f\"t0 = {Time.to_string(test_parameters.t_start)[0:23]}, t0_REF = {Time.to_string(test_parameters.t_start_ref)[0:23]}\"\n",
     ")\n",
     "\n",
     "dacc01_tt891a_df.plot(ax=ax1, marker=\".\")\n",
@@ -942,7 +449,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -967,12 +474,18 @@
     "report_filename_template = \"{}_{}-{}-{}_{}\"  # circuit_name, hwc_test, t_start, analysis_time, signature\n",
     "#\n",
     "analysis_start_time = Time.get_analysis_start_time()\n",
-    "prefix_circuit_name = circuit_name.split(\".\")[0]\n",
-    "hwc_test = hwc_test.split(\" \")[0]\n",
+    "prefix_circuit_name = test_parameters.circuit_name.split(\".\")[0]\n",
+    "hwc_test = test_parameters.hwc_test.split(\" \")[0]\n",
     "#\n",
-    "report_destination_path = report_destination_path_template.format(prefix_circuit_name, circuit_name, hwc_test)\n",
+    "report_destination_path = report_destination_path_template.format(\n",
+    "    prefix_circuit_name, test_parameters.circuit_name, hwc_test\n",
+    ")\n",
     "report_filename = report_filename_template.format(\n",
-    "    circuit_name, hwc_test, Time.to_datetime(t_start).strftime(\"%Y-%m-%d-%Hh%M\"), analysis_start_time, signature\n",
+    "    test_parameters.circuit_name,\n",
+    "    hwc_test,\n",
+    "    Time.to_datetime(test_parameters.t_start).strftime(\"%Y-%m-%d-%Hh%M\"),\n",
+    "    analysis_start_time,\n",
+    "    signature,\n",
     ")\n",
     "#\n",
     "!mkdir -p $report_destination_path\n",
diff --git a/mp3/Validation.ipynb b/mp3/Validation.ipynb
index 1706636ae88a6ce3758e22d5e0f03a8729ae380e..344f529afdb704f2d2b21a95a864bfb392fa16e1 100644
--- a/mp3/Validation.ipynb
+++ b/mp3/Validation.ipynb
@@ -246,16 +246,16 @@
    "source": [
     "def execute_analysis(row: pd.Series):\n",
     "    try:\n",
-    "        analysis = powering.get_analysis_instance(\n",
-    "            powering.TestParameterInput.create(\n",
-    "                hwc_test=hwc_test,\n",
-    "                circuit_name=row[\"systemName\"],\n",
-    "                campaign=row[\"campaign\"],\n",
-    "                t_start=row[\"executionStartTime\"],\n",
-    "                t_end=row[\"executionEndTime\"],\n",
-    "            ),\n",
-    "            summary_path,\n",
+    "        test_parameters = powering.get_analysis_test_input_parameters(\n",
+    "            hwc_summary_df,\n",
+    "            hwc_test,\n",
+    "            row[\"systemName\"],\n",
+    "            row[\"campaign\"],\n",
+    "            row[\"executionStartTime\"],\n",
+    "            row[\"executionEndTime\"],\n",
     "        )\n",
+    "        analysis_class = powering.get_analysis_class(hwc_test)\n",
+    "        analysis = analysis_class(\"\", test_parameters)\n",
     "        analysis.set_spark(spark)\n",
     "        analysis.query()\n",
     "        analysis.analyze()\n",
@@ -442,7 +442,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.18"
+   "version": "3.9.19"
   }
  },
  "nbformat": 4,