main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Documentation\n",
    "\n",
    "`main.ipynb` is a Jupyter Notebook file that serves as the main entry point for this project. It contains both the code and the narrative that explains what the code does. For further reference, please check out the technical documentation of this tool, which can be found [here](/README.md).\n",
    "\n",
    "This tool conducts the following analyses:\n",
    "\n",
    "- speed data analysis\n",
    "- c value modelling\n",
    "- stagnation pressure modelling\n",
    "\n",
    "To run this script, please use the following inputs:\n",
    "\n",
    "- `INPUT_DIRECTORY` - valid path to a directory containing raw `.igc` files\n",
    "- `OUTPUT_DIRECTORY` - valid path to an empty directory (output will be stored there)\n",
    "- `FILE_EXTENSION` - set to `.igc`\n",
    "\n",
    "Please note: The quality analysis can be conducted as soon as this script has been executed, because the quality check is based on this notebook.\n",
    "\n",
    "Happy processing!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from typing import List, Tuple\n",
    "from datetime import datetime\n",
    "\n",
    "import src.constants as constants\n",
    "import src.helpers.file_processor as file_processor\n",
    "import src.helpers.data_visualizer as data_visualizer\n",
    "import src.algorithms.speed_analyzer as speed_analyzer\n",
    "import src.algorithms.pressure_analyzer as pressure_analyzer\n",
    "import src.algorithms.c_values_analyzer as c_values_analyzer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_DIRECTORY: str = \"INPUT_DIRECTORY/\" # end with \"/\n",
    "OUTPUT_DIRECTORY: str = \"OUTPUT_DIRECTORY/\" # end with /\n",
    "FILE_EXTENSION: str = \".igc\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# objects\n",
    "c_analyzer = c_values_analyzer.CAnalyzer()\n",
    "file_processor = file_processor.FileProcessor()\n",
    "speed_analyzer = speed_analyzer.SpeedAnalyzer()\n",
    "data_visualizer = data_visualizer.DataVisualizer()\n",
    "pressure_analyzer = pressure_analyzer.PressureAnalyzer()\n",
    "\n",
    "# time\n",
    "timestamp: str = datetime.now().strftime(\"%Y%m%d-%H%M%S\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Pre-Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reference data\n",
    "theoretical_reference: pd.DataFrame = pd.read_csv(f\"{constants.THEORETICAL_REFERENCE_PATH}\")\n",
    "original_reference: pd.DataFrame = pd.read_csv(f\"{constants.ORIGINAL_REFERENCE_PATH}\")\n",
    "\n",
    "print(f\"Importing reference data:\")\n",
    "print(f\"--> Theoretical reference: {constants.THEORETICAL_REFERENCE_PATH.split('/')[-1]}\")\n",
    "print(f\"--> Original reference: {constants.ORIGINAL_REFERENCE_PATH.split('/')[-1]}\")\n",
    "print()\n",
    "\n",
    "# experimental data\n",
    "file_paths: List[str] = file_processor.get_file_paths(path=INPUT_DIRECTORY, file_extension=FILE_EXTENSION)\n",
    "\n",
    "print(f\"Importing experimental data:\")\n",
    "print(f\"--> Found {len(file_paths)} files.\")\n",
    "print(f\"--> The processing is initiated.\")\n",
    "print()\n",
    "\n",
    "data_raw: pd.DataFrame = speed_analyzer.process_raw_data(file_paths=file_paths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Speed Data Analyis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filter and group data\n",
    "theoretical_reference_filtered: pd.DataFrame = speed_analyzer.filter_raw_data(data=theoretical_reference, reference=True)\n",
    "original_reference_filtered: pd.DataFrame = speed_analyzer.filter_raw_data(data=original_reference, reference=True)\n",
    "data_raw_filtered: pd.DataFrame = speed_analyzer.filter_raw_data(data=data_raw)\n",
    "\n",
    "print(f\"Filtered data:\")\n",
    "print(f\"--> Data points for filtered theoretical reference: {len(theoretical_reference_filtered)} (lost {len(theoretical_reference) - len(theoretical_reference_filtered)})\")\n",
    "print(f\"--> Data points for filtered original reference: {len(original_reference_filtered)} (lost {len(original_reference) - len(original_reference_filtered)})\")\n",
    "print(f\"--> Data points for filtered tracklogs: {len(data_raw_filtered)} (lost {len(data_raw) - len(data_raw_filtered)})\")\n",
    "print()\n",
    "print(f\"Please note:\")\n",
    "print(f\"--> Why are so many raw data points lost? This is due to the fact that the system filters out all data point that are not on a straight line. This is done to ensure that the data is as accurate as possible.\")\n",
    "print()\n",
    "\n",
    "# smooth experimental data\n",
    "smoothed_data_raw: pd.DataFrame = speed_analyzer.savgol_filter(data=data_raw_filtered)\n",
    "smoothed_data_grouped: pd.DataFrame = speed_analyzer.group_data(data=smoothed_data_raw)\n",
    "\n",
    "print(f\"Data smoothing:\")\n",
    "print(f\"--> During smoothing, the raw data points were reduced from {len(data_raw_filtered)} to {len(smoothed_data_raw)} (lost {len(data_raw_filtered) - len(smoothed_data_raw)}).\")\n",
    "print(f\"--> During grouping, the smoothed data points were reduced from {len(smoothed_data_raw)} to {len(smoothed_data_grouped)} (lost {len(smoothed_data_raw) - len(smoothed_data_grouped)}).\")\n",
    "print()\n",
    "\n",
    "# export smoothed experimental data\n",
    "print(f\"Export data to CSV:\")\n",
    "print(f\"--> Exporting smoothed data to {timestamp}_SJf_smoothed-experimental-speed-data_nicolas-huber.csv.\")\n",
    "print(f\"--> Exporting grouped data to {timestamp}_SJf_experimental-speed-data_nicolas-huber.csv.\")\n",
    "print()\n",
    "\n",
    "speed_analyzer.export_to_csv(data=smoothed_data_raw, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_smoothed-experimental-speed-data_nicolas-huber.csv\")\n",
    "speed_analyzer.export_to_csv(data=smoothed_data_grouped, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_grouped-experimental-speed-data_nicolas-huber.csv\")\n",
    "\n",
    "# data visualization\n",
    "print(f\"Data visualization:\")\n",
    "print(f\"--> For reference, the theoretical and experimental speed data is visualized.\")\n",
    "\n",
    "data_visualizer.visualize_raw_speed_data(experimental_data=original_reference_filtered, theoretical_data=theoretical_reference_filtered, std_error=0.2, title=\"Experimentelle Geschwindigkeistdaten (original, 24.10.2022)\")\n",
    "data_visualizer.visualize_raw_speed_data(experimental_data=smoothed_data_grouped, theoretical_data=theoretical_reference_filtered, std_error=0.05, title=\"Experimentelle Geschwindigkeistdaten (optimiert, 31.03.2024)\")\n",
    "\n",
    "print(f\"--> To visualize the quality increase of the data (original [10/24/2022] vs. updated [03/31/2024]), the following two plots are shown:\")\n",
    "\n",
    "speed_deviation_original: Tuple[float, float, float, float] = data_visualizer.visualize_speed_deviation(experimental_data=original_reference_filtered, theoretical_data=theoretical_reference_filtered, speed_analyzer=speed_analyzer, title=\"Abweichung der experimentellen Geschwindigkeitsdaten (original, 24.10.2022)\")\n",
    "speed_deviation_optimized: Tuple[float, float, float, float] = data_visualizer.visualize_speed_deviation(experimental_data=smoothed_data_grouped, theoretical_data=theoretical_reference_filtered, speed_analyzer=speed_analyzer, title=\"Abweichung der experimentellen Geschwindigkeitsdaten (optimiert, 31.03.2024)\")\n",
    "\n",
    "# report\n",
    "score_original: float = speed_analyzer.score_stats(speed_deviation_original)\n",
    "score_optimized: float = speed_analyzer.score_stats(speed_deviation_optimized)\n",
    "\n",
    "print(f\"Report:\")\n",
    "speed_analyzer.print_report(score_original=score_original, score_optimized=score_optimized, deviation_original=speed_deviation_original, deviation_optimized=speed_deviation_optimized, datasets=[original_reference, original_reference_filtered, data_raw, smoothed_data_grouped])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C Value Modelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pre-process datasets\n",
    "print(f\"Manipulating datasets:\")\n",
    "print(f\"--> The datasets are being extended:\")\n",
    "print(f\"----> The original reference dataset is being extended with the airspeed, that's calculated based on horizontal and vertical speed.\")\n",
    "print(f\"----> The theoretical reference dataset is being extended with the airspeed, that's calculated based on horizontal and vertical speed.\")\n",
    "print(f\"----> The experimental dataset is being extended with the airspeed, that's calculated based on horizontal and vertical speed.\")\n",
    "print(f\"--> Vertical speeds are converted to be positive:\")\n",
    "print(f\"----> The vertical speeds of the original reference dataset are being converted to be positive.\")\n",
    "print(f\"----> The vertical speeds of the theoretical reference dataset are being converted to be positive.\")\n",
    "print(f\"----> The vertical speeds of the experimental dataset are being converted to be positive.\")\n",
    "\n",
    "airspeed_original_reference: pd.DataFrame = c_analyzer.positive_vertical_speed(speed_data=c_analyzer.calculate_airspeed(speed_data=original_reference_filtered))\n",
    "airspeed_theoretical_reference: pd.DataFrame = c_analyzer.positive_vertical_speed(speed_data=c_analyzer.calculate_airspeed(speed_data=theoretical_reference_filtered))\n",
    "airspeed_smoothed_data_grouped: pd.DataFrame = c_analyzer.positive_vertical_speed(speed_data=c_analyzer.calculate_airspeed(speed_data=smoothed_data_grouped))\n",
    "\n",
    "print(f\"--> The datasets have been extended and manipulated.\")\n",
    "print()\n",
    "\n",
    "# model c values\n",
    "print(f\"C values:\")\n",
    "print(f\"--> Calculating the c values for the following conditions:\")\n",
    "print(f\"----> Altitude: {constants.ALTITUDE} m\")\n",
    "print(f\"----> Air density: {constants.AIR_DENSITY} kg/m^3\")\n",
    "print(f\"----> Gravity: {constants.GRAVITY} m/s^2\")\n",
    "print(f\"----> Wing area: {constants.WING_AREA} m^2\")\n",
    "print(f\"----> Takeoff mass: {constants.MASS} kg\")\n",
    "print(f\"--> Calculating the c values for the following datasets:\")\n",
    "print(f\"----> The c values are being calculated for the original reference dataset (simplified & optimized algorithm).\")\n",
    "print(f\"----> The c values are being calculated for the theoretical reference dataset (simplified & optimized algorithm).\")\n",
    "print(f\"----> The c values are being calculated for the experimental dataset (simplified & optimized algorithm).\")\n",
    "\n",
    "c_values_original_reference_simplified: pd.DataFrame = c_analyzer.process_c_values(speed_data=airspeed_original_reference)\n",
    "c_values_original_reference_optimized: pd.DataFrame = c_analyzer.process_c_values(speed_data=airspeed_original_reference, algorithm=True)\n",
    "c_values_theoretical_reference_simplified: pd.DataFrame = c_analyzer.process_c_values(speed_data=airspeed_theoretical_reference)\n",
    "c_values_theoretical_reference_optimized: pd.DataFrame = c_analyzer.process_c_values(speed_data=airspeed_theoretical_reference, algorithm=True)\n",
    "c_values_experimental_simplified: pd.DataFrame = c_analyzer.process_c_values(speed_data=airspeed_smoothed_data_grouped)\n",
    "c_values_experimental_optimized: pd.DataFrame = c_analyzer.process_c_values(speed_data=airspeed_smoothed_data_grouped, algorithm=True)\n",
    "\n",
    "print(f\"--> The c values have been calculated.\")\n",
    "print()\n",
    "\n",
    "# export data\n",
    "print(f\"Export data to CSV:\")\n",
    "print(f\"--> The original reference dataset is being exported to the output directory (simplified algorithm): {timestamp}_SJf_flight-analyzer_c-values-original-reference_simplified_nicolas-huber.csv\")\n",
    "print(f\"--> The original reference dataset is being exported to the output directory (optimized algorithm): {timestamp}_SJf_flight-analyzer_c-values-original-reference_optimized_nicolas-huber.csv\")\n",
    "print(f\"--> The theoretical reference dataset is being exported to the output directory (simplified algorithm): {timestamp}_SJf_flight-analyzer_c-values-theoretical-reference_simplified_nicolas-huber.csv\")\n",
    "print(f\"--> The theoretical reference dataset is being exported to the output directory (optimized algorithm): {timestamp}_SJf_flight-analyzer_c-values-theoretical-reference_optimized_nicolas-huber.csv\")\n",
    "print(f\"--> The experimental dataset is being exported to the output directory (simplified algorithm): {timestamp}_SJf_flight-analyzer_c-values-experimental_simplified_nicolas-huber.csv\")\n",
    "print(f\"--> The experimental dataset is being exported to the output directory (optimized algorithm): {timestamp}_SJf_flight-analyzer_c-values-experimental_optimized_nicolas-huber.csv\")\n",
    "print()\n",
    "\n",
    "speed_analyzer.export_to_csv(data=c_values_original_reference_simplified, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_c-values-original-reference_simplified_nicolas-huber.csv\")\n",
    "speed_analyzer.export_to_csv(data=c_values_original_reference_optimized, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_c-values-original-reference_optimized_nicolas-huber.csv\")\n",
    "speed_analyzer.export_to_csv(data=c_values_theoretical_reference_simplified, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_c-values-theoretical-reference_simplified_nicolas-huber.csv\")\n",
    "speed_analyzer.export_to_csv(data=c_values_theoretical_reference_optimized, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_c-values-theoretical-reference_optimized_nicolas-huber.csv\")\n",
    "speed_analyzer.export_to_csv(data=c_values_experimental_simplified, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_c-values-experimental_simplified_nicolas-huber.csv\")\n",
    "speed_analyzer.export_to_csv(data=c_values_experimental_optimized, file_path=f\"{OUTPUT_DIRECTORY}/{timestamp}_SJf_flight-analyzer_c-values-experimental_optimized_nicolas-huber.csv\")\n",
    "\n",
    "# data visualization\n",
    "print(f\"Data visualization:\")\n",
    "print(f\"--> For reference, the c values modelled based on the theoretical data are plotted.\")\n",
    "print(f\"----> The c value model for the simplified algorithm (theoretical reference).\")\n",
    "\n",
    "data_visualizer.visualize_c_values_theoretical(theoretical_data=c_values_theoretical_reference_simplified, key='Ca [0.5]', title=\"Theoretische Ca-Werte (vereinfachter c-Algorithmus)\")\n",
    "data_visualizer.visualize_c_values_theoretical(theoretical_data=c_values_theoretical_reference_simplified, key='Cw [0.5]', title=\"Theoretische Cw-Werte (vereinfachter c-Algorithmus)\")\n",
    "\n",
    "print(f\"----> The c value model for the optimized algorithm (theoretical reference).\")\n",
    "\n",
    "data_visualizer.visualize_c_values_theoretical(theoretical_data=c_values_theoretical_reference_optimized, key='Ca [0.5]', title=\"Theoretische Ca-Werte (optimierter c-Algorithmus)\")\n",
    "data_visualizer.visualize_c_values_theoretical(theoretical_data=c_values_theoretical_reference_optimized, key='Cw [0.5]', title=\"Theoretische Cw-Werte (optimierter c-Algorithmus)\")\n",
    "\n",
    "print(f\"--> For reference, the c value models for the simplified algorithm are plotted:\")\n",
    "print(f\"----> Modelled c values for original reference dataset (simplified algorithm).\")\n",
    "\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_original_reference_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Ca [0.5]', title='Experimentelle vs. theoretische Ca-Werte (vereinfachter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_original_reference_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Cw [0.5]', title='Experimentelle vs. theoretische Cw-Werte (vereinfachter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "\n",
    "print(f\"---> Deviation of modelled c values for original reference dataset (simplified algorithm).\")\n",
    "\n",
    "deviation_ca_original_simplified: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_original_reference_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Ca [0.5]', title='Abweichung der Ca-Werte (vereinfachter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "deviation_cw_original_simplified: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_original_reference_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Cw [0.5]', title='Abweichung der Cw-Werte (vereinfachter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "\n",
    "print(f\"----> Modelled c values for experimental dataset (simplified algorithm).\")\n",
    "\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_experimental_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Ca [0.5]', title='Experimentelle vs. theoretische Ca-Werte (vereinfachter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_experimental_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Cw [0.5]', title='Experimentelle vs. theoretische Cw-Werte (vereinfachter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "\n",
    "print(f\"---> Deviation of modelled c values for experimental dataset (simplified algorithm).\")\n",
    "\n",
    "deviation_ca_experimental_simplified: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_experimental_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Ca [0.5]', title='Abweichung der Ca-Werte (vereinfachter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "deviation_cw_experimental_simplified: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_experimental_simplified, theoretical_data=c_values_theoretical_reference_simplified, key='Cw [0.5]', title='Abweichung der Cw-Werte (vereinfachter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "\n",
    "print(f\"--> For reference, the c value models for the optimized algorithm are plotted:\")\n",
    "print(f\"----> Modelled c values for original reference dataset (optimized algorithm).\")\n",
    "\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_original_reference_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Ca [0.5]', title='Experimentelle vs. theoretische Ca-Werte (optimierter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_original_reference_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Cw [0.5]', title='Experimentelle vs. theoretische Cw-Werte (optimierter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "\n",
    "print(f\"---> Deviation of modelled c values for original reference dataset (optimized algorithm).\")\n",
    "\n",
    "deviation_ca_original_optimized: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_original_reference_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Ca [0.5]', title='Abweichung der Ca-Werte (optimierter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "deviation_cw_original_optimized: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_original_reference_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Cw [0.5]', title='Abweichung der Cw-Werte (optimierter c-Algorithmus, originale Daten [24.10.2022])')\n",
    "\n",
    "print(f\"----> Modelled c values for experimental dataset (optimized algorithm).\")\n",
    "\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_experimental_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Ca [0.5]', title='Experimentelle vs. theoretische Ca-Werte (optimierter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "data_visualizer.visualize_c_values(experimental_data=c_values_experimental_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Cw [0.5]', title='Experimentelle vs. theoretische Cw-Werte (optimierter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "\n",
    "print(f\"---> Deviation of modelled c values for experimental dataset (optimized algorithm).\")\n",
    "\n",
    "deviation_ca_experimental_optimized: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_experimental_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Ca [0.5]', title='Abweichung der Ca-Werte (optimierter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "deviation_cw_experimental_optimized: Tuple[float, float, float, float] = data_visualizer.visualize_c_values_deviation(experimental_data=c_values_experimental_optimized, theoretical_data=c_values_theoretical_reference_optimized, key='Cw [0.5]', title='Abweichung der Cw-Werte (optimierter c-Algorithmus, optimierte Daten [31.03.2024])')\n",
    "\n",
    "# report\n",
    "score_original_ca_simplified: float = c_analyzer.score_stats(stats=deviation_ca_original_simplified)\n",
    "score_original_cw_simplified: float = c_analyzer.score_stats(stats=deviation_cw_original_simplified)\n",
    "score_experimental_ca_simplified: float = c_analyzer.score_stats(stats=deviation_ca_experimental_simplified)\n",
    "score_experimental_cw_simplified: float = c_analyzer.score_stats(stats=deviation_cw_experimental_simplified)\n",
    "score_original_ca_optimized: float = c_analyzer.score_stats(stats=deviation_ca_original_optimized)\n",
    "score_original_cw_optimized: float = c_analyzer.score_stats(stats=deviation_cw_original_optimized)\n",
    "score_experimental_ca_optimized: float = c_analyzer.score_stats(stats=deviation_ca_experimental_optimized)\n",
    "score_experimental_cw_optimized: float = c_analyzer.score_stats(stats=deviation_cw_experimental_optimized)\n",
    "\n",
    "c_analyzer.print_report(score_original_ca_simplified=score_original_ca_simplified, score_original_cw_simplified=score_original_cw_simplified, score_experimental_ca_simplified=score_experimental_ca_simplified, score_experimental_cw_simplified=score_experimental_cw_simplified, score_original_ca_optimized=score_original_ca_optimized, score_original_cw_optimized=score_original_cw_optimized, score_experimental_ca_optimized=score_experimental_ca_optimized, score_experimental_cw_optimized=score_experimental_cw_optimized)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stagnation Pressure Modelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model pressure\n",
    "print(f\"Pressure analysis:\")\n",
    "print(f\"--> The pressure data is being processed for the theoretical reference dataset.\")\n",
    "print(f\"--> The pressure data is being processed for the experimental dataset.\")\n",
    "print()\n",
    "\n",
    "pressure_data_theoretical: pd.DataFrame = pressure_analyzer.process_pressure_data(data=c_values_theoretical_reference_optimized)\n",
    "pressure_data_experimental: pd.DataFrame = pressure_analyzer.process_pressure_data(data=c_values_experimental_optimized)\n",
    "\n",
    "# export pressure data\n",
    "print(f\"Export to CSV:\")\n",
    "print(f\"The theoretical reference dataset is being exported to a CSV file: {OUTPUT_DIRECTORY}{timestamp}_SJf_flight-analyzer_dynamic-pressure_theoretical-reference_nicolas-huber.csv\")\n",
    "print(f\"The experimental dataset is being exported to a CSV file: {OUTPUT_DIRECTORY}{timestamp}_SJf_flight-analyzer_dynamic-pressure_experimental_nicolas-huber.csv\")\n",
    "print()\n",
    "\n",
    "pressure_analyzer.export_to_csv(data=pressure_data_theoretical, path=f\"{OUTPUT_DIRECTORY}{timestamp}_SJf_flight-analyzer_dynamic-pressure_theoretical-reference_nicolas-huber.csv\")\n",
    "pressure_analyzer.export_to_csv(data=pressure_data_experimental, path=f\"{OUTPUT_DIRECTORY}{timestamp}_SJf_flight-analyzer_dynamic-pressure_experimental_nicolas-huber.csv\")\n",
    "\n",
    "# data visualization\n",
    "print(f\"Data visualization:\")\n",
    "print(f\"--> The dynamic pressure data for the theoretical reference dataset is being visualized against the experimental dataset.\")\n",
    "\n",
    "data_visualizer.visualize_pressure(experimental_data=pressure_data_experimental, theoretical_data=pressure_data_theoretical, title=\"Experimentelle Modellierung des Staudrucks am Flügel\")\n",
    "data_visualizer.visualize_pressure_deviation(experimental_data=pressure_data_experimental, theoretical_data=pressure_data_theoretical, title=\"Abweichung des Staudrucks am Flügel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# System Info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"@ Author {constants.AUTHOR}\")\n",
    "print(f\"@ Author Email {constants.AUTHOR_EMAIL}\")\n",
    "print(f\"@ Author URL {constants.AUTHOR_URL}\")\n",
    "print(f\"@ GitHub URL {constants.GITHUB_URL}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}