ventilator_data_processing_301_600_ventilated.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](./Cerny_logo_1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Analysis of Cerny ventilation recordings\n",
    "\n",
    "## EDA on and further processing on clinical details and ventilator data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "This notebook imports the preprocessed **Fabian ventilator parameters** data from pickle archive and performs exploratory data analysis and further preprocessing on clinical details & ventilation modes and ventilator data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing the necessary libraries and setting options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import IPython\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import sklearn as sk\n",
    "\n",
    "import os\n",
    "import sys\n",
    "import re\n",
    "import pickle\n",
    "\n",
    "from scipy import stats\n",
    "from pandas import Series, DataFrame\n",
    "from datetime import datetime, timedelta\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) "
   ]
  },
  {
   "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(\"SciPy version: {}\".format(sp.__version__))\n",
    "print(\"IPython version: {}\".format(IPython.__version__))\n",
    "print(\"scikit-learn version: {}\".format(sk.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List and set the working directory and the directory to write out data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Topic of the Notebook which will also be the name of the subfolder containing results\n",
    "TOPIC = 'fabian'\n",
    "\n",
    "# Name of the external hard drive\n",
    "DRIVE = 'GUSZTI'\n",
    "\n",
    "# Directory containing clinical and blood gas data\n",
    "CWD = '/Users/guszti/ventilation_fabian'\n",
    "\n",
    "# Directory on external drive to read the ventilation data from\n",
    "DIR_READ = '/Volumes/%s/Fabian/fabian_data' % DRIVE\n",
    "\n",
    "DIR_WRITE = '%s/%s/%s' % (CWD, 'Analyses', 'analysis_ventilated_301_600')\n",
    "if not os.path.isdir(DIR_WRITE):\n",
    "    os.makedirs(DIR_WRITE)\n",
    "\n",
    "# Images and raw data will be written on an external hard drive\n",
    "if not os.path.isdir('/Volumes/%s/data_dump/%s' % (DRIVE, TOPIC)):\n",
    "    os.makedirs('/Volumes/%s/data_dump/%s' % (DRIVE, TOPIC))\n",
    "DATA_DUMP = '/Volumes/%s/data_dump/%s' % (DRIVE, TOPIC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(CWD)\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DIR_READ, DIR_WRITE, DATA_DUMP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import pickle archives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('%s/%s.pickle' % (DATA_DUMP, 'clin_df_301_600'), 'rb') as handle:\n",
    "    clin_df = pickle.load(handle)\n",
    "\n",
    "with open('%s/%s.pickle' % (DATA_DUMP, 'data_pars_measurements_301_600'), 'rb') as handle:\n",
    "    data_pars_measurements = pickle.load(handle)\n",
    "    \n",
    "with open('%s/%s.pickle' % (DATA_DUMP, 'data_pars_settings_301_600'), 'rb') as handle:\n",
    "    data_pars_settings = pickle.load(handle)\n",
    "    \n",
    "with open('%s/%s.pickle' % (DATA_DUMP, 'data_pars_alarms_301_600'), 'rb') as handle:\n",
    "    data_pars_alarms = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import table for interpreting ventilator parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "par_key_table = pd.read_excel('Fabian_parameters.xlsx')\n",
    "par_key_table;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How many recordings have we got for analysis\n"
   ]
  },
  {
   "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": {
    "scrolled": false
   },
   "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": [
    "vent_modes['ventilation'] = vent_modes['IPPV'] + vent_modes['SIMV'] + \\\n",
    "                            vent_modes['SIPPV'] + vent_modes['PSV'] + 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": {
    "scrolled": false
   },
   "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('%s/%s' % (DIR_WRITE, 'ventilation_modes_301_600.xlsx'))\n",
    "vent_modes.to_excel(writer, 'vent_modes')\n",
    "total_duration.to_excel(writer, 'total_duration')\n",
    "writer.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('%s/%s.pickle' % (DATA_DUMP, 'vent_modes_301_600'), '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": {
    "scrolled": false
   },
   "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']\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('%s/%s.pickle' % (DATA_DUMP, 'limit_301_600_ventilated'), 'rb') as handle:\n",
    "    limit = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "limit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(limit)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print(sorted(set(cases) - set(limit)))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "case = 'AL000595'"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "index = cases.index(case)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "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[case]['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] = ('2019-06-25 10:51:00', '2019-06-25 12:46:00')"
   ]
  },
  {
   "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": "raw",
   "metadata": {},
   "source": [
    "with open('%s/%s.pickle' % (DATA_DUMP, 'limit_301_600_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": {
    "scrolled": false
   },
   "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": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "vent_modes_ventilated.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add VG data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "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_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": {
    "scrolled": false
   },
   "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('%s/%s.pickle' % (DATA_DUMP, 'data_pars_measurements_ventilated_301_600'), 'wb') as handle:\n",
    "    pickle.dump(data_pars_measurements_ventilated, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "\n",
    "with open('%s/%s.pickle' % (DATA_DUMP, 'data_pars_settings_ventilated_301_600'), 'wb') as handle:\n",
    "    pickle.dump(data_pars_settings_ventilated, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "    \n",
    "with open('%s/%s.pickle' % (DATA_DUMP, 'data_pars_alarms_ventilated_301_600'), '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('%s/%s' % (DIR_WRITE, 'ventilation_modes_ventilated_301_600.xlsx'))\n",
    "vent_modes_ventilated.to_excel(writer, 'vent_modes_ventilated_301_600')\n",
    "total_duration_ventilated.to_excel(writer, 'total_duration_vent_301_600')\n",
    "writer.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('%s/%s.pickle' % (DATA_DUMP, 'vent_modes_ventilated_301_600'), '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",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}