ventilator_data_processing_1_1100_ventilated.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](./Cerny_logo_1.jpg)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "# Analysis of Cerny ventilation recordings\n",
    "\n",
    "#### Manual revision and trimming of ventilator recordings.\n",
    "\n",
    "This notebook imports the preprocessed **Fabian ventilator parameters** data from pickle archive and performs trimming based on manual inspection of data.\n",
    "\n",
    "The data processed and analysed in this Notebook were collected by the **Neonatal Emergency and Transport Service of the Peter Cerny Foundation**, Budapest, Hungary\n",
    "\n",
    "**Author: Dr Gusztav Belteki**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Import the required libraries and set options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import IPython\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import os\n",
    "import sys\n",
    "import pickle\n",
    "\n",
    "from pandas import Series, DataFrame\n",
    "from datetime import datetime, timedelta\n",
    "from matplotlib import dates\n",
    "\n",
    "%matplotlib inline\n",
    "matplotlib.style.use('classic')\n",
    "matplotlib.rcParams['figure.facecolor'] = 'w'\n",
    "\n",
    "pd.set_option('display.max_rows', 100)\n",
    "pd.set_option('display.max_columns', 100)\n",
    "# pd.set_option('mode.chained_assignment', None)\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Python version: {}\".format(sys.version))\n",
    "print(\"pandas version: {}\".format(pd.__version__))\n",
    "print(\"matplotlib version: {}\".format(matplotlib.__version__))\n",
    "print(\"NumPy version: {}\".format(np.__version__))\n",
    "print(\"IPython version: {}\".format(IPython.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. List and set the working directory and the directory to write out data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Name of the external hard drive\n",
    "DRIVE = 'GUSZTI'\n",
    "\n",
    "# Directory on external drive to read the clinical from\n",
    "DIR_READ = os.path.join(os.sep, 'Volumes', DRIVE, 'Fabian', 'fabian_patient_data_all')\n",
    "\n",
    "# Path to project folder containing ventilation research results\n",
    "PATH = os.path.join(os.sep, 'Users', 'guszti', 'Library', 'Mobile Documents', 'com~apple~CloudDocs', \n",
    "                            'Documents', 'Research', 'Ventilation')\n",
    "\n",
    "# Folder to export the result of analysis\n",
    "DIR_WRITE = os.path.join(PATH, 'ventilation_fabian', 'Analyses')\n",
    "os.makedirs(DIR_WRITE, exist_ok = True)\n",
    "\n",
    "# Folder on a USB stick to export data to and to import processed data exported by other Notebooks\n",
    "DATA_DUMP = os.path.join(os.sep, 'Volumes', DRIVE, 'data_dump', 'fabian',)\n",
    "os.makedirs(DATA_DUMP, exist_ok = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DIR_READ, DIR_WRITE, DATA_DUMP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Import pickle archives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(DATA_DUMP, 'clin_df_1_1100.pickle'), 'rb') as handle:\n",
    "    clin_df = pickle.load(handle)\n",
    "\n",
    "with open(os.path.join(DATA_DUMP, 'data_pars_measurements_1_1100.pickle'), 'rb') as handle:\n",
    "    data_pars_measurements = pickle.load(handle)\n",
    "    \n",
    "with open(os.path.join(DATA_DUMP, 'data_pars_settings_1_1100.pickle'), 'rb') as handle:\n",
    "    data_pars_settings = pickle.load(handle)\n",
    "    \n",
    "with open(os.path.join(DATA_DUMP, 'data_pars_alarms_1_1100.pickle'), 'rb') as handle:\n",
    "    data_pars_alarms = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(data_pars_measurements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cases = data_pars_measurements.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EDA on ventilation modes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### How many cases of the different ventilation modes occur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes = {}\n",
    "for case in cases:\n",
    "    # Multiply by two to get the number of seconds\n",
    "    vent_modes[case] = data_pars_settings[case]['Ventilator_mode'].value_counts() * 2\n",
    "    \n",
    "vent_modes = DataFrame(vent_modes).T\n",
    "\n",
    "vent_modes.replace(np.nan, 0, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the duration of the recordings\n",
    "\n",
    "recording_duration = {}\n",
    "\n",
    "for case in cases:\n",
    "    recording_duration[case] = 2 * len(data_pars_settings[case])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# No PSV\n",
    "vent_modes['ventilation'] = vent_modes['IPPV'] + vent_modes['SIMV'] + \\\n",
    "                            vent_modes['SIPPV'] + vent_modes['SIMVPSV']\n",
    "\n",
    "vent_modes['noninvasive'] = vent_modes['CPAP'] + vent_modes['DUOPAP'] + \\\n",
    "                            vent_modes['NCPAP'] + vent_modes['O2therapy']  \n",
    "\n",
    "vent_modes['total'] = Series(recording_duration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('SIMV:', sum(vent_modes['SIMV'] > 0))\n",
    "print('SIPPV:', sum(vent_modes['SIPPV'] > 0))\n",
    "# print('SIMVPSV:', sum(vent_modes['SIMVPSV'] > 0))\n",
    "#print('PSV:', sum(vent_modes['PSV'] > 0))\n",
    "print('IPPV:', sum(vent_modes['IPPV'] > 0))\n",
    "print('NCPAP:', sum(vent_modes['NCPAP'] > 0))\n",
    "print('CPAP:', sum(vent_modes['CPAP'] > 0))\n",
    "print('DUOPAP:', sum(vent_modes['DUOPAP'] > 0))\n",
    "print('O2therapy:', sum(vent_modes['O2therapy'] > 0))\n",
    "print('ventilation:', sum(vent_modes['ventilation'] > 0))\n",
    "print('noninvasive:', sum(vent_modes['noninvasive'] > 0))\n",
    "print('total', len(vent_modes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How many seconds of each ventilation mode in total?\n",
    "total_duration = DataFrame(vent_modes.sum(axis = 0), columns = ['duration (seconds)'])\n",
    "total_duration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Export Dataframes containing ventilator modes to Excel files and pickle archives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer = pd.ExcelWriter(os.path.join(DIR_WRITE, 'ventilation_modes_1_1100.xlsx'))\n",
    "vent_modes.to_excel(writer, 'vent_modes')\n",
    "total_duration.to_excel(writer, 'total_duration')\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(DATA_DUMP, 'vent_modes_1_1100'), 'wb') as handle:\n",
    "    pickle.dump(vent_modes, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Only consider those recordings that have at least 15 minutes (900 seconds) mechanical ventilation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated = vent_modes[vent_modes['ventilation'] > 900]\n",
    "len(vent_modes_ventilated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cases = sorted(vent_modes_ventilated.index)\n",
    "len(cases)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove recordings that had no flow working sensor and hence tidal volume measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "to_remove = ['AL000314', 'AL000350', 'AL000354', 'AL000401', 'AL000449', 'AL000459','AL000492', \n",
    "             'AL000493', 'AL000629', 'AL000828','AL000890', 'AL000893', 'AL000895', 'AL000897',\n",
    "             'AL000934', 'AL000944', 'AL000975', ]\n",
    "\n",
    "for case in to_remove:\n",
    "    if case in cases:\n",
    "        cases.remove(case)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove the periods from the beginning and the end of the recordings when the patient was not connected to the ventilator\n",
    "\n",
    "This requires manual inspection of the tidal volume and pressure graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This dictionary contains tuples of the start and end points as strings\n",
    "This was obtained by manual inspection of VTmand and PIP and the recordings\n",
    "and manually removing the start and the end when the baby was not on the ventilator (e.g. no VTmand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(DATA_DUMP, 'limit_1_300_ventilated.pickle'), 'rb') as handle:\n",
    "    limit_1_300 = pickle.load(handle)\n",
    "with open(os.path.join(DATA_DUMP, 'limit_301_600_ventilated.pickle'), 'rb') as handle:\n",
    "    limit_301_600 = pickle.load(handle)\n",
    "with open(os.path.join(DATA_DUMP, 'limit_601_900_ventilated.pickle'), 'rb') as handle:\n",
    "    limit_601_900 = pickle.load(handle)\n",
    "with open(os.path.join(DATA_DUMP, 'limit_901_1100_ventilated.pickle'), 'rb') as handle:\n",
    "    limit_901_1100 = pickle.load(handle)\n",
    "\n",
    "limit = {**limit_1_300, **limit_301_600, **limit_601_900, **limit_901_1100}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "limit;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(limit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(set(cases) - set(limit)))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "case = sorted(set(cases) - set(limit))[0]\n",
    "\n",
    "index = cases.index(case)\n",
    "index"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "vent_modes_ventilated.loc[case]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "case = cases[index]\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(10, 8)\n",
    "fig.subplots_adjust(left=None, bottom=None, right=None, top=None, \n",
    "                            wspace=None, hspace=0.05)\n",
    "\n",
    "ax0 = fig.add_subplot(2, 1, 1)\n",
    "data_pars_measurements['AL000314']['VTemand_kg'].plot()\n",
    "ax0.get_xaxis().set_visible(False)\n",
    "ax0.set_ylabel('mL/kg', size = 12, color = 'black')\n",
    "ax0.set_title(case,  size = 12, color = 'black')\n",
    "ax0.legend('VTemand_kg', fontsize = 10, loc = 'best')\n",
    "ax0.grid('on', linestyle='-', linewidth=0.5, color = 'gray')\n",
    "ax0.tick_params(which = 'both', labelsize=12)\n",
    "\n",
    "ax1 = fig.add_subplot(2, 1, 2)\n",
    "data_pars_measurements[case]['PIP'].plot(color = 'red')\n",
    "ax1.set_xlabel('Time', size = 12, color = 'black')\n",
    "ax1.set_ylabel('cmH2O)', size = 12, color = 'black')\n",
    "ax1.legend('PIP', fontsize = 10, loc = 'best')\n",
    "ax1.grid('on', linestyle='-', linewidth=0.5, color = 'gray')\n",
    "ax1.tick_params(which = 'both', labelsize=12)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print(\"limit[case] = ('%s', '%s')\" % (data_pars_measurements[case].index[0], data_pars_measurements[case].index[-1]))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "limit[case] = ('2018-08-01 16:59:00', '2018-08-01 17:43:30')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "fig = plt.figure()\n",
    "fig.set_size_inches(10, 8)\n",
    "fig.subplots_adjust(left=None, bottom=None, right=None, top=None, \n",
    "                            wspace=None, hspace=0.05)\n",
    "\n",
    "ax0 = fig.add_subplot(2, 1, 1)\n",
    "data_pars_measurements[case]['VTemand_kg'][limit[case][0] : limit[case][1]].plot()\n",
    "ax0.get_xaxis().set_visible(False)\n",
    "ax0.set_ylabel('mL/kg', size = 12, color = 'black')\n",
    "ax0.set_title(case,  size = 12, color = 'black')\n",
    "ax0.legend('VTemand_kg', fontsize = 10, loc = 'best')\n",
    "ax0.grid('on', linestyle='-', linewidth=0.5, color = 'gray')\n",
    "ax0.tick_params(which = 'both', labelsize=12)\n",
    "\n",
    "ax1 = fig.add_subplot(2, 1, 2)\n",
    "data_pars_measurements[case]['PIP'][limit[case][0] : limit[case][1]].plot(color = 'red')\n",
    "ax1.set_xlabel('Time', size = 12, color = 'black')\n",
    "ax1.set_ylabel('cmH2O)', size = 12, color = 'black')\n",
    "ax1.legend('PIP', fontsize = 10, loc = 'best')\n",
    "ax1.grid('on', linestyle='-', linewidth=0.5, color = 'gray')\n",
    "ax1.tick_params(which = 'both', labelsize=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(DATA_DUMP, 'limit_1_1100_ventilated'), 'wb') as handle:\n",
    "    pickle.dump(limit, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trim ventilator data using the manual filters\n",
    "\n",
    "data_pars_measurements_ventilated = {}\n",
    "data_pars_settings_ventilated = {}\n",
    "data_pars_alarms_ventilated = {}\n",
    "\n",
    "for case in cases:\n",
    "    data_pars_measurements_ventilated[case] = data_pars_measurements[case][limit[case][0] : limit[case][1]]\n",
    "    data_pars_settings_ventilated[case] = data_pars_settings[case][limit[case][0] : limit[case][1]]\n",
    "    data_pars_alarms_ventilated[case] = data_pars_alarms[case][limit[case][0] : limit[case][1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now re-analyse the filtered data as above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### How many cases of the different ventilation modes occur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated = {}\n",
    "for case in cases:\n",
    "    # Multiply by two to get the number of seconds\n",
    "    vent_modes_ventilated[case] = data_pars_settings_ventilated[case]['Ventilator_mode'].value_counts() * 2\n",
    "    \n",
    "vent_modes_ventilated = DataFrame(vent_modes_ventilated).T\n",
    "\n",
    "vent_modes_ventilated.replace(np.nan, 0, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the duration of the recordings\n",
    "\n",
    "recording_duration = {}\n",
    "\n",
    "for case in cases:\n",
    "    recording_duration[case] = 2 * len(data_pars_settings[case])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add VG data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VG = {}\n",
    "for case in cases:\n",
    "    try:\n",
    "        # Multiply by two to get the number of seconds\n",
    "        VG[case] = data_pars_settings_ventilated[case]['VG_state'].value_counts() * 2\n",
    "    except KeyError:\n",
    "        VG[case] = np.zeros(1)\n",
    "        # print('No VG_state for %s' % case)\n",
    "        \n",
    "VG = DataFrame(VG).T\n",
    "VG.columns = ['VG_off','VG_on']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated = pd.concat([vent_modes_ventilated, VG], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the duration of the recordings\n",
    "\n",
    "recording_duration_ventilated = {}\n",
    "\n",
    "for case in cases:\n",
    "    recording_duration_ventilated[case] = 2 * len(data_pars_settings_ventilated[case])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated['total'] = Series(recording_duration_ventilated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How many seconds of each ventilation mode in total?\n",
    "total_duration_ventilated = DataFrame(vent_modes_ventilated.sum(axis = 0), columns = ['duration (seconds)'])\n",
    "total_duration_ventilated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Only consider those recordings that have at least 15 minutes (900 seconds) mechanical ventilation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# After the trimming all but one recording remained longer than 15 minutes. \n",
    "# Remove that\n",
    "\n",
    "len(vent_modes_ventilated[vent_modes_ventilated['total'] > 900])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated = vent_modes_ventilated[vent_modes_ventilated['total'] > 900]\n",
    "cases = sorted(vent_modes_ventilated.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(vent_modes_ventilated), len(cases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vent_modes_ventilated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('SIMV:', sum(vent_modes_ventilated['SIMV'] > 0))\n",
    "print('SIPPV:', sum(vent_modes_ventilated['SIPPV'] > 0))\n",
    "# print('SIMVPSV:', sum(vent_modes_ventilated['SIMVPSV'] > 0))\n",
    "# print('PSV:', sum(vent_modes_ventilated['PSV'] > 0))\n",
    "print('IPPV:', sum(vent_modes_ventilated['IPPV'] > 0))\n",
    "print('VG_on:', sum(vent_modes_ventilated['VG_on'] > 0))\n",
    "print('total', len(vent_modes_ventilated))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(vent_modes_ventilated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(cases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_pars_measurements_ventilated = {rec : data_pars_measurements_ventilated[rec] for rec \n",
    "                                     in data_pars_measurements_ventilated\n",
    "                                     if rec in cases}\n",
    "\n",
    "data_pars_settings_ventilated = {rec : data_pars_settings_ventilated[rec] for rec \n",
    "                                     in data_pars_settings_ventilated\n",
    "                                     if rec in cases}\n",
    "\n",
    "data_pars_alarms_ventilated = {rec : data_pars_alarms_ventilated[rec] for rec \n",
    "                                     in data_pars_alarms_ventilated\n",
    "                                     if rec in cases}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export trimmed DataFrames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(DATA_DUMP, 'data_pars_measurements_ventilated_1_1100.pickle'), 'wb') as handle:\n",
    "    pickle.dump(data_pars_measurements_ventilated, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "\n",
    "with open(os.path.join(DATA_DUMP, 'data_pars_settings_ventilated_1_1100.pickle'), 'wb') as handle:\n",
    "    pickle.dump(data_pars_settings_ventilated, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "    \n",
    "with open(os.path.join(DATA_DUMP, 'data_pars_alarms_ventilated_1_1100.pickle'), 'wb') as handle:\n",
    "    pickle.dump(data_pars_alarms_ventilated, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export Dataframes containing ventilator modes to Excel files and pickle archives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer = pd.ExcelWriter(os.path.join(DIR_WRITE, 'ventilation_modes_ventilated_1_1100.xlsx'))\n",
    "vent_modes_ventilated.to_excel(writer, 'vent_modes_ventilated_1_1100')\n",
    "total_duration_ventilated.to_excel(writer, 'total_duration_vent_1_1100')\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(DATA_DUMP, 'vent_modes_ventilated_1_1100.pickle'), 'wb') as handle:\n",
    "    pickle.dump(vent_modes_ventilated, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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": 4
}