Tapping_analysis_cont_circ_final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0ea08536",
   "metadata": {},
   "source": [
    "Here are all code you need for whole analysis, it consists of 7 tapping tasks.\n",
    "The tapping test has 6 + 1 tasks:\n",
    "-\ttapping to music at 80, 120 and 150 bpm (3 tasks) --> SMS\n",
    "-\ttapping to metronome at 80, 120 and 150 bpm (3 tasks) --> SMS\n",
    "-\ttapping without stimulus (1 task) --> SMT"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0496cb9e",
   "metadata": {},
   "source": [
    "In case there are some problems because it would not allow you to run code (excels writing), you should run jupyter notebook through admin: ALT + f + s + a, when you are in folder"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecbfb52d",
   "metadata": {},
   "source": [
    "What are inputs files? Look at readme."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfa2045d",
   "metadata": {},
   "source": [
    "## Installing and importing packages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c715618c",
   "metadata": {},
   "source": [
    "In general you install all packeges as stated below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c4d86a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install jupyterthemes #installation process for almost all packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baacba37",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Install all packages from python to R for using in Python\n",
    "\n",
    "import rpy2.robjects.packages as rpackages\n",
    "\n",
    "\n",
    "utils = importr('utils')\n",
    "base = importr('base')\n",
    "\n",
    "utils.chooseCRANmirror()\n",
    "\n",
    "utils.install_packages('readxl')\n",
    "utils.install_packages('circular')\n",
    "utils.install_packages('openxlsx')\n",
    "utils.install_packages('readr')\n",
    "utils.install_packages('rlang')\n",
    "\n",
    "readxl = importr('readxl')\n",
    "circular = importr('circular')\n",
    "openxlsx = importr('openxlsx')\n",
    "readr = importr('readr')\n",
    "rlang = importr('rlang')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f32ab26d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#All packeges needed in this code\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import glob\n",
    "import os\n",
    "import scipy\n",
    "import rpy2\n",
    "from rpy2.robjects.packages import importr, data\n",
    "from rpy2 import robjects\n",
    "import math\n",
    "import xlsxwriter\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aae3fc15",
   "metadata": {},
   "source": [
    "## Same def for all files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ce1fba7",
   "metadata": {},
   "source": [
    "Rename files - delete ending"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "931926e5",
   "metadata": {},
   "source": [
    "In process ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d63adb53",
   "metadata": {},
   "source": [
    "For naming after participant code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7553adb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Used when you give path with \"/\", not optimized yet\n",
    "def get_name1(file):\n",
    "    name = str(file)\n",
    "    replacementStr = \"\"\n",
    "    \n",
    "    n = name.rfind('/')\n",
    "\n",
    "    name = name.replace(name[0 : n+1], replacementStr, 1)\n",
    "    name = name.replace(name[-4 :], replacementStr, 1)\n",
    "\n",
    "    return name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63371878",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Used when you give path with \"\\\", normally for windows\n",
    "def get_name2(file):\n",
    "    name = str(file)\n",
    "    replacementStr = \"\"\n",
    "    \n",
    "    n = name.rfind(\"\\\\\")\n",
    "\n",
    "    name = name.replace(name[0 : n+1], replacementStr, 1)\n",
    "    name = name.replace(name[-4 :], replacementStr, 1)\n",
    "\n",
    "    return name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5b785eb",
   "metadata": {},
   "source": [
    "##### Read file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe5e4126",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_edit_csv3(file): #what kind of file is used - in readme\n",
    "    df = pd.read_csv(file, encoding=\"utf-8\", index_col=False)\n",
    "    name = get_name2(file)\n",
    "\n",
    "    df[\"TrackName\"] = name\n",
    "    df = df.filter(['secs into Track','TrackName'])\n",
    "    df.rename(columns={'secs into Track': name}, inplace=True)\n",
    "    df = df.drop('TrackName', axis = 1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11482527",
   "metadata": {},
   "source": [
    "# 80 - Functions on one sheet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe1070eb",
   "metadata": {},
   "source": [
    "#### First two filters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fdd63ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Input from csv and eliminate differences smaller than 0.1\n",
    "def ioi_lim_alone_80(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['Difference'] = df.diff()\n",
    "    first = df.iloc[:,0].tolist()\n",
    "    second = df.iloc[:,1].tolist()\n",
    "\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                vrstica2 = float('NaN')\n",
    "                second[i] = vrstica2\n",
    "            \n",
    "    df1 = pd.DataFrame({'ioi':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    df = df.rename(columns={\"ioi\": name})\n",
    "    df = df.iloc[: , 1:]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59a3706c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Add to raw data cleaning (2.625<x<21) in sec\n",
    "def ioi_lim_clean_80(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line < 2.625 or line > 21:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'clean': first})\n",
    "    \n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f504e650",
   "metadata": {},
   "source": [
    "#### Outlier filtering "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e548261",
   "metadata": {},
   "source": [
    "After filtering, the first 10 valid taps are deleted from the beginning of each trial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71d91b88",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_filt10_80(file):\n",
    "    df = ioi_lim_clean_80(file)\n",
    "    \n",
    "    df['diff'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "    \n",
    "    delete = 0\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "            elif vrstica2 != 0 and delete < 10:\n",
    "                second[i] = 0\n",
    "                delete += 1\n",
    "    \n",
    "                           \n",
    "    df1 = pd.DataFrame({'filter10':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73109631",
   "metadata": {},
   "source": [
    "Function for clean, filter and delete first 10 valid taps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1c1bc43",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean10_80(file):\n",
    "    df = ioi_lim_filt10_80(file)\n",
    "       \n",
    "    \n",
    "    df['filtered'] = np.where(df['filter10'] == 0,\n",
    "                             df['filter10'], df['clean'])\n",
    "    \n",
    "    df['filtered'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "\n",
    "    return df #return data frame with columns: input track, clean, diff, filter10, filtered"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3df7682c",
   "metadata": {},
   "source": [
    "Add REF column to the data frame and delete columns that are not used anymore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96ddbf0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_prep_80(file):\n",
    "    df = ioi_lim_clean10_80(file)\n",
    "    df = df.drop(['clean', 'diff', 'filter10'], axis=1)\n",
    "    \n",
    "    s = [0]\n",
    "    x = 0\n",
    "    while x < 50:\n",
    "        x += 0.75\n",
    "        s.append(x)\n",
    "\n",
    "    df['REF'] = pd.Series(s)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54550062",
   "metadata": {},
   "source": [
    "Find nearest values from REF and calculate diff."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05b0dc02",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_80(file):\n",
    "    df = df_prep_80(file)\n",
    "    \n",
    "    df['diff_s'] = (pd.merge_asof(df['filtered'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_s'] = (df['diff_s']/0.75)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e10c1e04",
   "metadata": {},
   "source": [
    "### IOI data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19cf7bb2",
   "metadata": {},
   "source": [
    "Give you data frame with ioi data from all participants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11a40916",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_files_80(directory):\n",
    "    seznam = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "        for filename in [f for f in filenames if f.endswith(\"80.csv\")]: #search for all 80 files\n",
    "            seznam.append(os.path.join(dirpath, filename))\n",
    "            \n",
    "    return seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f08246e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_frame_80(directory):\n",
    "    \n",
    "    seznam = get_files_80(directory)\n",
    "    li = []    \n",
    "    \n",
    "    for filename in seznam:\n",
    "        df = ioi_lim_alone_80(filename)\n",
    "        li.append(df)\n",
    "\n",
    "    frame = pd.concat(li, axis=1, ignore_index=False)\n",
    "    \n",
    "    return frame"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aeb369f1",
   "metadata": {},
   "source": [
    "##### Concatenate just IOI data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec25abf1",
   "metadata": {},
   "source": [
    "### IOI-limits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b40a5c50",
   "metadata": {},
   "source": [
    "Add columns with all values together and calculate M, SD, Q1, Q3, IQR, MAX, MIN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60f8ca9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_ioi_calc_80(directory):\n",
    "    frame = ioi_frame_80(directory)\n",
    "    frame['combined']= frame.values.tolist()\n",
    "    li = []\n",
    "\n",
    "    for row in frame['combined']:\n",
    "        for vsak in row:\n",
    "            li.append(vsak)\n",
    "\n",
    "    new_array = [x for x in li if math.isnan(x) == False]\n",
    "    se = pd.Series(new_array)\n",
    "    \n",
    "    df_ioi = pd.DataFrame([new_array])\n",
    "    df_ioi = df_ioi.T\n",
    "    df_ioi['all_80'] = pd.DataFrame(data=se)\n",
    "    df_ioi = df_ioi.iloc[: , 1:]\n",
    "    \n",
    "    return df_ioi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df7ca0ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_limits_80(directory):\n",
    "    frame = ioi_frame_80(directory)\n",
    "    df_ioi = list_ioi_calc_80(directory)\n",
    "    \n",
    "    df_ioi['mean'] = [(df_ioi['all_80'].mean())]+['']*(len(df_ioi)-1)\n",
    "    frame['mean'] = df_ioi['mean']\n",
    "    \n",
    "    df_ioi['std'] = [(df_ioi['all_80'].std())]+['']*(len(df_ioi)-1)\n",
    "    frame['std'] = df_ioi['std']\n",
    "    \n",
    "    df_ioi['q1'] = [(df_ioi['all_80'].quantile(.25, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q1'] = df_ioi['q1']\n",
    "    \n",
    "    df_ioi['q3'] = [(df_ioi['all_80'].quantile(.75, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q3'] = df_ioi['q3']\n",
    "    \n",
    "    df_ioi['IQR'] = [(df_ioi['q3'].iloc[0] - df_ioi['q1'].iloc[0])]+['']*(len(df_ioi)-1)\n",
    "    frame['IQR'] = df_ioi['IQR']\n",
    "    \n",
    "    df_ioi['min'] = [(df_ioi['q1'].iloc[0] - (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['min'] = df_ioi['min']\n",
    "    \n",
    "    df_ioi['max'] = [(df_ioi['q3'].iloc[0] + (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['max'] = df_ioi['max']\n",
    "    \n",
    "    return df_ioi.to_excel('df_ioi_80.xlsx'), frame.to_excel('IOI_filter_80.xlsx')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bde5ab0",
   "metadata": {},
   "source": [
    "### Circular analysis from R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23cdfdbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_80(file):\n",
    "    prep = prep_for_r_80(file)\n",
    "    circ_in_r_80(prep)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcf24208",
   "metadata": {},
   "source": [
    "Create xlsx with angel column to put in R code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7ea2808",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_80(file):\n",
    "    df = df_diff_angle_80(file)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_s'])\n",
    "        \n",
    "    return df_a.to_excel('angle_80.xlsx')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bce006c6",
   "metadata": {},
   "source": [
    "Call R function and provide calculations, merge them in participant dataframe. Change path for excel documents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aba20cbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Be careful you installed all packages\n",
    "\n",
    "#Excecute R circular analysis and make xlsx file with measurement\n",
    "\n",
    "#Change to right path and name of this files later in code\n",
    "#write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "#circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "\n",
    "def circ_in_r_80(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_80 <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_80[1] <- NULL\n",
    "\n",
    "          circ80 <- data.frame(ID = colnames(angle_80), \n",
    "                               RAY_s = NA,\n",
    "                               RAYsig_s = NA,\n",
    "                               MEAN_s = NA,\n",
    "                               Rho_s = NA)\n",
    "\n",
    "          for(i in 1:length(circ80$ID)){\n",
    "            a <- angle_80[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ80$RAY_s[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ80$RAYsig_s[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ80$MEAN_s[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ80$Rho_s[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeea4b09",
   "metadata": {},
   "source": [
    "Read excel with circular data and delete angle_80 and circ80_stat files. Check is RAYsig p value is lareger than 0.05."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09877d25",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_80(file):\n",
    "    circular_80(file)\n",
    "    \n",
    "    df1 = df_diff_angle_80(file)\n",
    "    df2 = pd.read_excel('circ80_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_80.xlsx\")\n",
    "    os.remove(\"circ80_stat.xlsx\")\n",
    "    \n",
    "    #if you want the notification if RAYsig is above 0.05, uncomment next three lines\n",
    "    \n",
    "    #if df['RAYsig_s'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_s'] = 'RAYsig_s > 0.05'\n",
    "      #  df.at[0, 'Rho_s'] = 'RAYsig_s > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e130a585",
   "metadata": {},
   "source": [
    "## Continuation phase"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dba16d6a",
   "metadata": {},
   "source": [
    "Add abs(DIF) column, calculated both means, add contMTC column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "748d974d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_80(file):\n",
    "    df = final_circ_80(file)\n",
    "    \n",
    "    df['abs_diff_s'] = df['diff_s'].abs()\n",
    "    df['m_diff_s'] = [np.mean(df['diff_s'])]+['']*(len(df)-1)\n",
    "    df['m_abs_s'] = [np.mean(df['abs_diff_s'])]+['']*(len(df)-1)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line <= 21:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'contMTC': first})\n",
    "\n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c30410f9",
   "metadata": {},
   "source": [
    "### Add ioi filter and proceed last calculations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f2b5a9c",
   "metadata": {},
   "source": [
    "Concatenate df_ioi_80 excel with cont_mtc_80."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e62afba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_concat_80(file, directory):\n",
    "    excels = ioi_limits_80(directory)\n",
    "    \n",
    "    df1 = cont_mtc_80(file)\n",
    "    df2 = pd.read_excel('df_ioi_80.xlsx', usecols=lambda x: 'Unnamed' not in x,)\n",
    "    \n",
    "    df2 = df2.drop('all_80', axis=1)\n",
    "    \n",
    "    frames = [df1, df2]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    os.remove(\"df_ioi_80.xlsx\")\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7786d03",
   "metadata": {},
   "source": [
    "## Circular analysis of continuation phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bed9050d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_filter_80(file, directory):\n",
    "    df = final_concat_80(file, directory)\n",
    "    \n",
    "    df['differ'] = df['contMTC'].diff()\n",
    "    first = df['contMTC'].tolist()\n",
    "    second = df['differ'].tolist()\n",
    "    \n",
    "    \n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "    \n",
    "    for vsak in first:\n",
    "        if vsak != 0 and vsak > 20:\n",
    "            prvi = vsak\n",
    "            break\n",
    "    \n",
    "    on = [prvi] + second\n",
    "    \n",
    "    col = second\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 30:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 30:\n",
    "            col[i] = 0\n",
    "        \n",
    "    df1 = pd.DataFrame({'filter_c':col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    df['filtered_c'] = np.where(df['filter_c'] == 0,\n",
    "                             df['filter_c'], df['contMTC'])\n",
    "    \n",
    "    df['filtered_c'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    df = df.drop(['differ', 'filter_c'], axis = 1)\n",
    "    \n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ddceef7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_c_80(file, directory):\n",
    "    df = cont_mtc_filter_80(file, directory)\n",
    "    \n",
    "    df['diff_c'] = (pd.merge_asof(df['filtered_c'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered_c', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered_c'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_c'] = (df['diff_c']/0.75)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b09723a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_c_80(file, directory):\n",
    "    prep = prep_for_r_c_80(file, directory)\n",
    "    circ_in_r_c_80(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc64e03e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_c_80(file, directory):\n",
    "    df = df_diff_angle_c_80(file, directory)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_c'])\n",
    "        \n",
    "    return df_a.to_excel('angle_c_80.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9881f807",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Be careful you installed all packages\n",
    "\n",
    "#Excecute R circular analysis and make xlsx file with measurement\n",
    "\n",
    "#Change to right path and name of this files later in code\n",
    "#write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "#circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "\n",
    "def circ_in_r_c_80(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_c_80 <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_c_80[1] <- NULL\n",
    "\n",
    "          circ80c <- data.frame(ID = colnames(angle_c_80), \n",
    "                               RAY_c = NA,\n",
    "                               RAYsig_c = NA,\n",
    "                               MEAN_c = NA,\n",
    "                               Rho_c = NA)\n",
    "\n",
    "          for(i in 1:length(circ80c$ID)){\n",
    "            a <- angle_c_80[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ80c$RAY_c[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ80c$RAYsig_c[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ80c$MEAN_c[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ80c$Rho_c[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ80c,\"C:/Users/Neza/Downloads/tapping/circ80c_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_c_80.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0e69a6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_c_80(file, directory):\n",
    "    circular_c_80(file, directory)\n",
    "    \n",
    "    df1 = df_diff_angle_c_80(file, directory)\n",
    "    df2 = pd.read_excel('circ80c_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_c_80.xlsx\")\n",
    "    os.remove(\"circ80c_stat.xlsx\")\n",
    "    \n",
    "    #if you want the notification if RAYsig is above 0.05, uncomment next three lines\n",
    "\n",
    "    #if df['RAYsig_c'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_c'] = 'RAYsig_c > 0.05'\n",
    "      #  df.at[0, 'Rho_c'] = 'RAYsig_c > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbf833c5",
   "metadata": {},
   "source": [
    "## Cont IOI measures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b20972d3",
   "metadata": {},
   "source": [
    "From contMTC delete if difference is out of calculated ioi limits. More than 29 taps are eliminated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6025ee3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_ioi_filt_80(file, directory):\n",
    "    df = final_circ_c_80(file, directory)\n",
    "    \n",
    "    df['Difference'] = df['contMTC'].diff()\n",
    "    first = df['Difference'].tolist()\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < (df['min'].iloc[0]) or vrstica > (df['max'].iloc[0]):\n",
    "            first[i] = 0            \n",
    "            \n",
    "    df1 = pd.DataFrame({'preIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    \n",
    "    col = df['preIOI'].tolist()\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 29:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 29:\n",
    "            col[i] = 0\n",
    "\n",
    "    df1 = pd.DataFrame({'preIOI_29': col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29db9afc",
   "metadata": {},
   "source": [
    "ContIOI calculated: delete smaller than 0.1 and outliers based on quartiles of participant (preIOI quartiles)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdf56be7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_ioi_final_80(file, directory):\n",
    "    df = pre_ioi_filt_80(file, directory)\n",
    "    df['contMTC'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI_29'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    first = df['preIOI_29'].tolist()\n",
    "    \n",
    "    q1 = np.quantile(first, .25)\n",
    "    q3 = np.quantile(first, .75)\n",
    "    iqr = q3 - q1\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < 0.1 or vrstica < (q1 - (3*iqr)) or vrstica > (q3 + (3*iqr)):\n",
    "            first[i] = 0\n",
    "            \n",
    "            \n",
    "    df1 = pd.DataFrame({'contIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df['contIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "535d6573",
   "metadata": {},
   "source": [
    "Last measures: avg, std, IOI elemszám, TÖRÖLNI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb778d1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_calc_80(file, directory):\n",
    "    df = cont_ioi_final_80(file, directory)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['mIOIcont'] = [df['contIOI'].mean()]+['']*(len(df)-1)\n",
    "    df['CVcont'] = [(df['contIOI'].std())/(df['mIOIcont'].iloc[0])]+['']*(len(df)-1)\n",
    "    \n",
    "    df['IOIelemszam'] = [((df['contIOI'] != 0).sum())]+['']*(len(df)-1)\n",
    "    #df['torolni'] = [(df['IOIelemszam'].iloc[0]) - 29]+['']*(len(df)-1) --> might be used\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e1b8cd",
   "metadata": {},
   "source": [
    "# 80m - Functions on one sheet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05f7c3b6",
   "metadata": {},
   "source": [
    "Everything same as in 80, just on metronome, all calculations are same. Same comments, so look up for more info."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7aa0b7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_alone_80m(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    name = get_name2(file)\n",
    "    \n",
    "    df['Difference'] = df.diff()\n",
    "    first = df.iloc[:,0].tolist()\n",
    "    second = df.iloc[:,1].tolist()\n",
    "\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                vrstica2 = float('NaN')\n",
    "                second[i] = vrstica2\n",
    "            \n",
    "    df1 = pd.DataFrame({'ioi':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    df = df.rename(columns={\"ioi\": name})\n",
    "    df = df.iloc[: , 1:]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da5357e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean_80m(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line < 2.625 or line > 21:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'clean': first})\n",
    "    \n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c82858b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_filt10_80m(file):\n",
    "    df = ioi_lim_clean_80m(file)\n",
    "    \n",
    "    df['diff'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "    \n",
    "    delete = 0\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "            elif vrstica2 != 0 and delete < 10:\n",
    "                second[i] = 0\n",
    "                delete += 1\n",
    "    \n",
    "                           \n",
    "    df1 = pd.DataFrame({'filter10':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efadb588",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean10_80m(file):\n",
    "    df = ioi_lim_filt10_80m(file)\n",
    "       \n",
    "    \n",
    "    df['filtered'] = np.where(df['filter10'] == 0,\n",
    "                             df['filter10'], df['clean'])\n",
    "    \n",
    "    df['filtered'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "\n",
    "    return df "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5b81fe3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_prep_80m(file):\n",
    "    df = ioi_lim_clean10_80m(file)\n",
    "    df = df.drop(['clean', 'diff', 'filter10'], axis=1)\n",
    "    \n",
    "    s = [0]\n",
    "    x = 0\n",
    "    while x < 50:\n",
    "        x += 0.75\n",
    "        s.append(x)\n",
    "\n",
    "    df['REF'] = pd.Series(s)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6112cc9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_80m(file):\n",
    "    df = df_prep_80m(file)\n",
    "    \n",
    "    df['diff_s'] = (pd.merge_asof(df['filtered'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_s'] = (df['diff_s']/0.75)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9765c7be",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_files_80m(directory):\n",
    "    seznam = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory): \n",
    "        for filename in [f for f in filenames if f.endswith(\"80m.csv\")]: \n",
    "            seznam.append(os.path.join(dirpath, filename))\n",
    "            \n",
    "    return seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be335970",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_frame_80m(directory):\n",
    "    \n",
    "    seznam = get_files_80m(directory)\n",
    "    li = []    \n",
    "    \n",
    "    for filename in seznam:\n",
    "        df = ioi_lim_alone_80m(filename)\n",
    "        li.append(df)\n",
    "\n",
    "    frame = pd.concat(li, axis=1, ignore_index=False)\n",
    "    \n",
    "    return frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4e65302",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_ioi_calc_80m(directory):\n",
    "    frame = ioi_frame_80m(directory)\n",
    "    frame['combined']= frame.values.tolist()\n",
    "    li = []\n",
    "\n",
    "    for row in frame['combined']:\n",
    "        for vsak in row:\n",
    "            li.append(vsak)\n",
    "\n",
    "    new_array = [x for x in li if math.isnan(x) == False]\n",
    "    se = pd.Series(new_array)\n",
    "    \n",
    "    df_ioi = pd.DataFrame([new_array])\n",
    "    df_ioi = df_ioi.T\n",
    "    df_ioi['all_80m'] = pd.DataFrame(data=se)\n",
    "    df_ioi = df_ioi.iloc[: , 1:]\n",
    "    \n",
    "    return df_ioi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1696eaad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_limits_80m(directory):\n",
    "    frame = ioi_frame_80m(directory)\n",
    "    df_ioi = list_ioi_calc_80m(directory)\n",
    "    \n",
    "    df_ioi['mean'] = [(df_ioi['all_80m'].mean())]+['']*(len(df_ioi)-1)\n",
    "    frame['mean'] = df_ioi['mean']\n",
    "    \n",
    "    df_ioi['std'] = [(df_ioi['all_80m'].std())]+['']*(len(df_ioi)-1)\n",
    "    frame['std'] = df_ioi['std']\n",
    "    \n",
    "    df_ioi['q1'] = [(df_ioi['all_80m'].quantile(.25, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q1'] = df_ioi['q1']\n",
    "    \n",
    "    df_ioi['q3'] = [(df_ioi['all_80m'].quantile(.75, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q3'] = df_ioi['q3']\n",
    "    \n",
    "    df_ioi['IQR'] = [(df_ioi['q3'].iloc[0] - df_ioi['q1'].iloc[0])]+['']*(len(df_ioi)-1)\n",
    "    frame['IQR'] = df_ioi['IQR']\n",
    "    \n",
    "    df_ioi['min'] = [(df_ioi['q1'].iloc[0] - (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['min'] = df_ioi['min']\n",
    "    \n",
    "    df_ioi['max'] = [(df_ioi['q3'].iloc[0] + (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['max'] = df_ioi['max']\n",
    "    \n",
    "    return df_ioi.to_excel('df_ioi_80m.xlsx'), frame.to_excel('IOI_filter_80m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b52cf21",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_80m(file):\n",
    "    prep = prep_for_r_80m(file)\n",
    "    circ_in_r_80m(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "503360e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_80m(file):\n",
    "    df = df_diff_angle_80m(file)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_s'])\n",
    "        \n",
    "    return df_a.to_excel('angle_s_80m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c90be23",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Change to the right path, where should be excel files made\n",
    "\n",
    "def circ_in_r_80m(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_s_80m <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_s_80m[1] <- NULL\n",
    "\n",
    "          circ_s_80m <- data.frame(ID = colnames(angle_s_80m), \n",
    "                               RAY_s = NA,\n",
    "                               RAYsig_s = NA,\n",
    "                               MEAN_s = NA,\n",
    "                               Rho_s = NA)\n",
    "\n",
    "          for(i in 1:length(circ_s_80m$ID)){\n",
    "            a <- angle_s_80m[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ_s_80m$RAY_s[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ_s_80m$RAYsig_s[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ_s_80m$MEAN_s[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ_s_80m$Rho_s[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ_s_80m,\"C:/Users/Neza/Downloads/tapping/circ_s_80m_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_s_80m.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "402f465b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_80m(file):\n",
    "    circular_80m(file)\n",
    "    \n",
    "    df1 = df_diff_angle_80m(file)\n",
    "    df2 = pd.read_excel('circ_s_80m_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_s_80m.xlsx\")\n",
    "    os.remove(\"circ_s_80m_stat.xlsx\")\n",
    "    \n",
    "    #if df['RAYsig_s'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_s'] = 'RAYsig_s > 0.05'\n",
    "      #  df.at[0, 'Rho_s'] = 'RAYsig_s > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3519c2d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_80m(file):\n",
    "    df = final_circ_80m(file)\n",
    "    \n",
    "    df['abs_diff'] = df['diff_s'].abs()\n",
    "    df['m_diff'] = [np.mean(df['diff_s'])]+['']*(len(df)-1)\n",
    "    df['m_abs'] = [np.mean(df['abs_diff'])]+['']*(len(df)-1)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line <= 21:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'contMTC': first})\n",
    "\n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9abf29b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_concat_80m(file, directory):\n",
    "    excels = ioi_limits_80m(directory)\n",
    "    \n",
    "    df1 = cont_mtc_80m(file)\n",
    "    df2 = pd.read_excel('df_ioi_80m.xlsx', usecols=lambda x: 'Unnamed' not in x,)\n",
    "    \n",
    "    df2 = df2.drop('all_80m', axis=1)\n",
    "    \n",
    "    frames = [df1, df2]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    os.remove(\"df_ioi_80m.xlsx\")\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5d6711d",
   "metadata": {},
   "source": [
    "## Circular analysis of continuation phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac3d3c15",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_filter_80m(file, directory):\n",
    "    df = final_concat_80m(file, directory)\n",
    "    \n",
    "    df['differ'] = df['contMTC'].diff()\n",
    "    first = df['contMTC'].tolist()\n",
    "    second = df['differ'].tolist()\n",
    "    \n",
    "    \n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "    \n",
    "    for vsak in first:\n",
    "        if vsak != 0 and vsak > 20:\n",
    "            prvi = vsak\n",
    "            break\n",
    "    \n",
    "    on = [prvi] + second\n",
    "    \n",
    "    col = second\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 30:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 30:\n",
    "            col[i] = 0\n",
    "        \n",
    "    df1 = pd.DataFrame({'filter_c':col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    df['filtered_c'] = np.where(df['filter_c'] == 0,\n",
    "                             df['filter_c'], df['contMTC'])\n",
    "    \n",
    "    df['filtered_c'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    df = df.drop(['differ', 'filter_c'], axis = 1)\n",
    "    \n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51525c0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_c_80m(file, directory):\n",
    "    df = cont_mtc_filter_80m(file, directory)\n",
    "    \n",
    "    df['diff_c'] = (pd.merge_asof(df['filtered_c'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered_c', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered_c'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_c'] = (df['diff_c']/0.75)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e80b67c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_c_80m(file, directory):\n",
    "    prep = prep_for_r_c_80m(file, directory)\n",
    "    circ_in_r_c_80m(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e3b5b8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_c_80m(file, directory):\n",
    "    df = df_diff_angle_c_80m(file, directory)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_c'])\n",
    "        \n",
    "    return df_a.to_excel('angle_c_80m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d920955",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Be careful you installed all packages\n",
    "\n",
    "#Excecute R circular analysis and make xlsx file with measurement\n",
    "\n",
    "#Change to right path and name of this files later in code\n",
    "#write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "#circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "\n",
    "def circ_in_r_c_80m(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_c_80m <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_c_80m[1] <- NULL\n",
    "\n",
    "          circ80mc <- data.frame(ID = colnames(angle_c_80m), \n",
    "                               RAY_c = NA,\n",
    "                               RAYsig_c = NA,\n",
    "                               MEAN_c = NA,\n",
    "                               Rho_c = NA)\n",
    "\n",
    "          for(i in 1:length(circ80mc$ID)){\n",
    "            a <- angle_c_80m[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ80mc$RAY_c[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ80mc$RAYsig_c[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ80mc$MEAN_c[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ80mc$Rho_c[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ80mc,\"C:/Users/Neza/Downloads/tapping/circ80mc_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_c_80m.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1653a569",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_c_80m(file, directory):\n",
    "    circular_c_80m(file, directory)\n",
    "    \n",
    "    df1 = df_diff_angle_c_80m(file, directory)\n",
    "    df2 = pd.read_excel('circ80mc_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_c_80m.xlsx\")\n",
    "    os.remove(\"circ80mc_stat.xlsx\")\n",
    "    \n",
    "    #if you want the notification if RAYsig is above 0.05, uncomment next three lines\n",
    "\n",
    "    #if df['RAYsig_c'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_c'] = 'RAYsig_c > 0.05'\n",
    "      #  df.at[0, 'Rho_c'] = 'RAYsig_c > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd61ad9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_ioi_filt_80m(file, directory):\n",
    "    df = final_circ_c_80m(file, directory)\n",
    "    \n",
    "    df['Difference'] = df['contMTC'].diff()\n",
    "    first = df['Difference'].tolist()\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < (df['min'].iloc[0]) or vrstica > (df['max'].iloc[0]):\n",
    "            first[i] = 0            \n",
    "            \n",
    "    df1 = pd.DataFrame({'preIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    \n",
    "    col = df['preIOI'].tolist()\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 29:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 29:\n",
    "            col[i] = 0\n",
    "\n",
    "    df1 = pd.DataFrame({'preIOI_29': col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e47afac9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_ioi_final_80m(file, directory):\n",
    "    df = pre_ioi_filt_80m(file, directory)\n",
    "    df['contMTC'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI_29'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    first = df['preIOI_29'].tolist()\n",
    "    \n",
    "    q1 = np.quantile(first, .25)\n",
    "    q3 = np.quantile(first, .75)\n",
    "    iqr = q3 - q1\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < 0.1 or vrstica < (q1 - (3*iqr)) or vrstica > (q3 + (3*iqr)):\n",
    "            first[i] = 0\n",
    "            \n",
    "            \n",
    "    df1 = pd.DataFrame({'contIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df['contIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35ba35d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_calc_80m(file, directory):\n",
    "    df = cont_ioi_final_80m(file, directory)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['mIOIcont'] = [df['contIOI'].mean()]+['']*(len(df)-1)\n",
    "    df['CVcont'] = [(df['contIOI'].std())/(df['mIOIcont'].iloc[0])]+['']*(len(df)-1)\n",
    "    \n",
    "    df['IOIelemszam'] = [((df['contIOI'] != 0).sum())]+['']*(len(df)-1)\n",
    "    #df['torolni'] = [(df['IOIelemszam'].iloc[0]) - 29]+['']*(len(df)-1)\n",
    "        \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bc2435b",
   "metadata": {},
   "source": [
    "# 120"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2bff743",
   "metadata": {},
   "source": [
    "Same as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05ff6366",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_alone_120(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['Difference'] = df.diff()\n",
    "    first = df.iloc[:,0].tolist()\n",
    "    second = df.iloc[:,1].tolist()\n",
    "\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                vrstica2 = float('NaN')\n",
    "                second[i] = vrstica2\n",
    "            \n",
    "    df1 = pd.DataFrame({'ioi':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    df = df.rename(columns={\"ioi\": name})\n",
    "    df = df.iloc[: , 1:]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8a60425",
   "metadata": {},
   "source": [
    "Add to raw data clean (1.75<x<28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fee9d69e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean_120(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line < 1.75 or line > 28:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'clean': first})\n",
    "    \n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d309a3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_filt10_120(file):\n",
    "    df = ioi_lim_clean_120(file)\n",
    "    \n",
    "    df['diff'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "    \n",
    "    delete = 0\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "            elif vrstica2 != 0 and delete < 10:\n",
    "                second[i] = 0\n",
    "                delete += 1\n",
    "    \n",
    "                           \n",
    "    df1 = pd.DataFrame({'filter10':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb7d9113",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean10_120(file):\n",
    "    df = ioi_lim_filt10_120(file)\n",
    "       \n",
    "    \n",
    "    df['filtered'] = np.where(df['filter10'] == 0,\n",
    "                             df['filter10'], df['clean'])\n",
    "    \n",
    "    df['filtered'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e467005",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_prep_120(file):\n",
    "    df = ioi_lim_clean10_120(file)\n",
    "    df = df.drop(['clean', 'diff', 'filter10'], axis=1)\n",
    "    \n",
    "    s = [0]\n",
    "    x = 0\n",
    "    while x < 50:\n",
    "        x += 0.5\n",
    "        s.append(x)\n",
    "\n",
    "    df['REF'] = pd.Series(s)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65a1b12a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_120(file):\n",
    "    df = df_prep_120(file)\n",
    "    \n",
    "    df['diff_s'] = (pd.merge_asof(df['filtered'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_s'] = (df['diff_s']/0.5)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cded9571",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_files_120(directory):\n",
    "    seznam = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory):\n",
    "        for filename in [f for f in filenames if f.endswith(\"120.csv\")]:\n",
    "            seznam.append(os.path.join(dirpath, filename))\n",
    "            \n",
    "    return seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcc143bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_frame_120(directory):\n",
    "    \n",
    "    seznam = get_files_120(directory)\n",
    "    li = []    \n",
    "    \n",
    "    for filename in seznam:\n",
    "        df = ioi_lim_alone_120(filename)\n",
    "        li.append(df)\n",
    "\n",
    "    frame = pd.concat(li, axis=1, ignore_index=False)\n",
    "    \n",
    "    return frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29b51785",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_ioi_calc_120(directory):\n",
    "    frame = ioi_frame_120(directory)\n",
    "    frame['combined']= frame.values.tolist()\n",
    "    li = []\n",
    "\n",
    "    for row in frame['combined']:\n",
    "        for vsak in row:\n",
    "            li.append(vsak)\n",
    "\n",
    "    new_array = [x for x in li if math.isnan(x) == False]\n",
    "    se = pd.Series(new_array)\n",
    "    \n",
    "    df_ioi = pd.DataFrame([new_array])\n",
    "    df_ioi = df_ioi.T\n",
    "    df_ioi['all_120'] = pd.DataFrame(data=se)\n",
    "    df_ioi = df_ioi.iloc[: , 1:]\n",
    "    \n",
    "    return df_ioi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ea2baba",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_limits_120(directory):\n",
    "    frame = ioi_frame_120(directory)\n",
    "    df_ioi = list_ioi_calc_120(directory)\n",
    "    \n",
    "    df_ioi['mean'] = [(df_ioi['all_120'].mean())]+['']*(len(df_ioi)-1)\n",
    "    frame['mean'] = df_ioi['mean']\n",
    "    \n",
    "    df_ioi['std'] = [(df_ioi['all_120'].std())]+['']*(len(df_ioi)-1)\n",
    "    frame['std'] = df_ioi['std']\n",
    "    \n",
    "    df_ioi['q1'] = [(df_ioi['all_120'].quantile(.25, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q1'] = df_ioi['q1']\n",
    "    \n",
    "    df_ioi['q3'] = [(df_ioi['all_120'].quantile(.75, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q3'] = df_ioi['q3']\n",
    "    \n",
    "    df_ioi['IQR'] = [(df_ioi['q3'].iloc[0] - df_ioi['q1'].iloc[0])]+['']*(len(df_ioi)-1)\n",
    "    frame['IQR'] = df_ioi['IQR']\n",
    "    \n",
    "    df_ioi['min'] = [(df_ioi['q1'].iloc[0] - (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['min'] = df_ioi['min']\n",
    "    \n",
    "    df_ioi['max'] = [(df_ioi['q3'].iloc[0] + (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['max'] = df_ioi['max']\n",
    "    \n",
    "    return df_ioi.to_excel('df_ioi_120.xlsx'), frame.to_excel('IOI_filter_120.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be656e7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_120(file):\n",
    "    prep = prep_for_r_120(file)\n",
    "    circ_in_r_120(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b726b8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_120(file):\n",
    "    df = df_diff_angle_120(file)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_s'])\n",
    "        \n",
    "    return df_a.to_excel('angle_s_120.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23c709ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Change to the right path, where should be excel files made\n",
    "\n",
    "def circ_in_r_120(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_s_120 <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_s_120[1] <- NULL\n",
    "\n",
    "          circ120s <- data.frame(ID = colnames(angle_s_120), \n",
    "                               RAY_s = NA,\n",
    "                               RAYsig_s = NA,\n",
    "                               MEAN_s = NA,\n",
    "                               Rho_s = NA)\n",
    "\n",
    "          for(i in 1:length(circ120s$ID)){\n",
    "            a <- angle_s_120[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ120s$RAY_s[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ120s$RAYsig_s[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ120s$MEAN_s[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ120s$Rho_s[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ120s,\"C:/Users/Neza/Downloads/tapping/circ120s_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_s_120.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4941dce2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_120(file):\n",
    "    circular_120(file)\n",
    "    \n",
    "    df1 = df_diff_angle_120(file)\n",
    "    df2 = pd.read_excel('circ120s_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_s_120.xlsx\")\n",
    "    os.remove(\"circ120s_stat.xlsx\")\n",
    "    \n",
    "    #if df['RAYsig_s'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_s'] = 'RAYsig_s > 0.05'\n",
    "      #  df.at[0, 'Rho_s'] = 'RAYsig_s > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b530129",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_120(file):\n",
    "    df = final_circ_120(file)\n",
    "    \n",
    "    df['abs_diff'] = df['diff_s'].abs()\n",
    "    df['m_diff'] = [np.mean(df['diff_s'])]+['']*(len(df)-1)\n",
    "    df['m_abs'] = [np.mean(df['abs_diff'])]+['']*(len(df)-1)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line <= 28:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'contMTC': first})\n",
    "\n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3acede20",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_concat_120(file, directory):\n",
    "    excels = ioi_limits_120(directory)\n",
    "    \n",
    "    df1 = cont_mtc_120(file)\n",
    "    df2 = pd.read_excel('df_ioi_120.xlsx', usecols=lambda x: 'Unnamed' not in x,)\n",
    "    \n",
    "    df2 = df2.drop('all_120', axis=1)\n",
    "    \n",
    "    frames = [df1, df2]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    os.remove(\"df_ioi_120.xlsx\")\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50acfa48",
   "metadata": {},
   "source": [
    "## Circular analysis of continuation phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e8cab9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_filter_120(file, directory):\n",
    "    df = final_concat_120(file, directory)\n",
    "    \n",
    "    df['differ'] = df['contMTC'].diff()\n",
    "    first = df['contMTC'].tolist()\n",
    "    second = df['differ'].tolist()\n",
    "    \n",
    "    \n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "    \n",
    "    for vsak in first:\n",
    "        if vsak != 0 and vsak > 20:\n",
    "            prvi = vsak\n",
    "            break\n",
    "    \n",
    "    on = [prvi] + second\n",
    "    \n",
    "    col = second\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 30:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 30:\n",
    "            col[i] = 0\n",
    "        \n",
    "    df1 = pd.DataFrame({'filter_c':col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    df['filtered_c'] = np.where(df['filter_c'] == 0,\n",
    "                             df['filter_c'], df['contMTC'])\n",
    "    \n",
    "    df['filtered_c'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    df = df.drop(['differ', 'filter_c'], axis = 1)\n",
    "    \n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c304d2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_c_120(file, directory):\n",
    "    df = cont_mtc_filter_120(file, directory)\n",
    "    \n",
    "    df['diff_c'] = (pd.merge_asof(df['filtered_c'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered_c', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered_c'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_c'] = (df['diff_c']/0.5)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01026ab4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_c_120(file, directory):\n",
    "    prep = prep_for_r_c_120(file, directory)\n",
    "    circ_in_r_c_120(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b9ac375",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_c_120(file, directory):\n",
    "    df = df_diff_angle_c_120(file, directory)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_c'])\n",
    "        \n",
    "    return df_a.to_excel('angle_c_120.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "532423d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Be careful you installed all packages\n",
    "\n",
    "#Excecute R circular analysis and make xlsx file with measurement\n",
    "\n",
    "#Change to right path and name of this files later in code\n",
    "#write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "#circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "\n",
    "def circ_in_r_c_120(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_c_120 <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_c_120[1] <- NULL\n",
    "\n",
    "          circ120c <- data.frame(ID = colnames(angle_c_120), \n",
    "                               RAY_c = NA,\n",
    "                               RAYsig_c = NA,\n",
    "                               MEAN_c = NA,\n",
    "                               Rho_c = NA)\n",
    "\n",
    "          for(i in 1:length(circ120c$ID)){\n",
    "            a <- angle_c_120[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ120c$RAY_c[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ120c$RAYsig_c[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ120c$MEAN_c[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ120c$Rho_c[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ120c,\"C:/Users/Neza/Downloads/tapping/circ120c_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_c_120.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "648a53fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_c_120(file, directory):\n",
    "    circular_c_120(file, directory)\n",
    "    \n",
    "    df1 = df_diff_angle_c_120(file, directory)\n",
    "    df2 = pd.read_excel('circ120c_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_c_120.xlsx\")\n",
    "    os.remove(\"circ120c_stat.xlsx\")\n",
    "    \n",
    "    #if you want the notification if RAYsig is above 0.05, uncomment next three lines\n",
    "\n",
    "    #if df['RAYsig_c'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_c'] = 'RAYsig_c > 0.05'\n",
    "      #  df.at[0, 'Rho_c'] = 'RAYsig_c > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7827a3e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_ioi_filt_120(file, directory):\n",
    "    df = final_circ_c_120(file, directory)\n",
    "    \n",
    "    df['Difference'] = df['contMTC'].diff()\n",
    "    first = df['Difference'].tolist()\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < (df['min'].iloc[0]) or vrstica > (df['max'].iloc[0]):\n",
    "            first[i] = 0            \n",
    "            \n",
    "    df1 = pd.DataFrame({'preIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    \n",
    "    col = df['preIOI'].tolist()\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 29:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 29:\n",
    "            col[i] = 0\n",
    "\n",
    "    df1 = pd.DataFrame({'preIOI_29': col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28f01796",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_ioi_final_120(file, directory):\n",
    "    df = pre_ioi_filt_120(file, directory)\n",
    "    df['contMTC'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI_29'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    first = df['preIOI_29'].tolist()\n",
    "    \n",
    "    q1 = np.quantile(first, .25)\n",
    "    q3 = np.quantile(first, .75)\n",
    "    iqr = q3 - q1\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < 0.1 or vrstica < (q1 - (3*iqr)) or vrstica > (q3 + (3*iqr)):\n",
    "            first[i] = 0\n",
    "            \n",
    "            \n",
    "    df1 = pd.DataFrame({'contIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df['contIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31bd8229",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_calc_120(file, directory):\n",
    "    df = cont_ioi_final_120(file, directory)\n",
    "    \n",
    "    df['mIOIcont'] = [df['contIOI'].mean()]+['']*(len(df)-1)\n",
    "    df['CVcont'] = [(df['contIOI'].std())/(df['mIOIcont'].iloc[0])]+['']*(len(df)-1)\n",
    "    \n",
    "    df['IOIelemszam'] = [((df['contIOI'] != 0).sum())]+['']*(len(df)-1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b2217ad",
   "metadata": {},
   "source": [
    "# 120m - Functions on one sheet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a1a5cac",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_alone_120m(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    name = get_name2(file)\n",
    "    \n",
    "    df['Difference'] = df.diff()\n",
    "    first = df.iloc[:,0].tolist()\n",
    "    second = df.iloc[:,1].tolist()\n",
    "\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                vrstica2 = float('NaN')\n",
    "                second[i] = vrstica2\n",
    "            \n",
    "    df1 = pd.DataFrame({'ioi':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    df = df.rename(columns={\"ioi\": name})\n",
    "    df = df.iloc[: , 1:]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e10206de",
   "metadata": {},
   "source": [
    "Add to raw data clean (1.75<x<28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05a0b97b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean_120m(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line < 1.7 or line > 28:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'clean': first})\n",
    "    \n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4694fef6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_filt10_120m(file):\n",
    "    df = ioi_lim_clean_120m(file)\n",
    "    \n",
    "    df['diff'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "    \n",
    "    delete = 0\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "            elif vrstica2 != 0 and delete < 10:\n",
    "                second[i] = 0\n",
    "                delete += 1\n",
    "    \n",
    "                           \n",
    "    df1 = pd.DataFrame({'filter10':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61824cf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean10_120m(file):\n",
    "    df = ioi_lim_filt10_120m(file)\n",
    "       \n",
    "    \n",
    "    df['filtered'] = np.where(df['filter10'] == 0,\n",
    "                             df['filter10'], df['clean'])\n",
    "    \n",
    "    df['filtered'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "654ef698",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_prep_120m(file):\n",
    "    df = ioi_lim_clean10_120m(file)\n",
    "    df = df.drop(['clean', 'diff', 'filter10'], axis=1)\n",
    "    \n",
    "    s = [0]\n",
    "    x = 0\n",
    "    while x < 50:\n",
    "        x += 0.5\n",
    "        s.append(x)\n",
    "\n",
    "    df['REF'] = pd.Series(s)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2de3cf22",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_120m(file):\n",
    "    df = df_prep_120m(file)\n",
    "    \n",
    "    df['diff_s'] = (pd.merge_asof(df['filtered'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_s'] = (df['diff_s']/0.5)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9205c5b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_files_120m(directory):\n",
    "    seznam = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory):\n",
    "        for filename in [f for f in filenames if f.endswith(\"120m.csv\")]:\n",
    "            seznam.append(os.path.join(dirpath, filename))\n",
    "            \n",
    "    return seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f460f7a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_frame_120m(directory):\n",
    "    \n",
    "    seznam = get_files_120m(directory)\n",
    "    li = []    \n",
    "    \n",
    "    for filename in seznam:\n",
    "        df = ioi_lim_alone_120m(filename)\n",
    "        li.append(df)\n",
    "\n",
    "    frame = pd.concat(li, axis=1, ignore_index=False)\n",
    "    \n",
    "    return frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "998e344d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_ioi_calc_120m(directory):\n",
    "    frame = ioi_frame_120m(directory)\n",
    "    frame['combined']= frame.values.tolist()\n",
    "    li = []\n",
    "\n",
    "    for row in frame['combined']:\n",
    "        for vsak in row:\n",
    "            li.append(vsak)\n",
    "\n",
    "    new_array = [x for x in li if math.isnan(x) == False]\n",
    "    se = pd.Series(new_array)\n",
    "    \n",
    "    df_ioi = pd.DataFrame([new_array])\n",
    "    df_ioi = df_ioi.T\n",
    "    df_ioi['all_120m'] = pd.DataFrame(data=se)\n",
    "    df_ioi = df_ioi.iloc[: , 1:]\n",
    "    \n",
    "    return df_ioi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "241569e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_limits_120m(directory):\n",
    "    frame = ioi_frame_120m(directory)\n",
    "    df_ioi = list_ioi_calc_120m(directory)\n",
    "    \n",
    "    df_ioi['mean'] = [(df_ioi['all_120m'].mean())]+['']*(len(df_ioi)-1)\n",
    "    frame['mean'] = df_ioi['mean']\n",
    "    \n",
    "    df_ioi['std'] = [(df_ioi['all_120m'].std())]+['']*(len(df_ioi)-1)\n",
    "    frame['std'] = df_ioi['std']\n",
    "    \n",
    "    df_ioi['q1'] = [(df_ioi['all_120m'].quantile(.25, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q1'] = df_ioi['q1']\n",
    "    \n",
    "    df_ioi['q3'] = [(df_ioi['all_120m'].quantile(.75, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q3'] = df_ioi['q3']\n",
    "    \n",
    "    df_ioi['IQR'] = [(df_ioi['q3'].iloc[0] - df_ioi['q1'].iloc[0])]+['']*(len(df_ioi)-1)\n",
    "    frame['IQR'] = df_ioi['IQR']\n",
    "    \n",
    "    df_ioi['min'] = [(df_ioi['q1'].iloc[0] - (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['min'] = df_ioi['min']\n",
    "    \n",
    "    df_ioi['max'] = [(df_ioi['q3'].iloc[0] + (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['max'] = df_ioi['max']\n",
    "    \n",
    "    return df_ioi.to_excel('df_ioi_120m.xlsx'), frame.to_excel('IOI_filter_120m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed706344",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_120m(file):\n",
    "    prep = prep_for_r_120m(file)\n",
    "    circ_in_r_120m(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79070944",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_120m(file):\n",
    "    df = df_diff_angle_120m(file)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_s'])\n",
    "        \n",
    "    return df_a.to_excel('angle_s_120m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28e22c82",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Change to the right path, where should be excel files made\n",
    "\n",
    "def circ_in_r_120m(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_s_120m <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_s_120m[1] <- NULL\n",
    "\n",
    "          circ_s_120m <- data.frame(ID = colnames(angle_s_120m), \n",
    "                               RAY_s = NA,\n",
    "                               RAYsig_s = NA,\n",
    "                               MEAN_s = NA,\n",
    "                               Rho_s = NA)\n",
    "\n",
    "          for(i in 1:length(circ_s_120m$ID)){\n",
    "            a <- angle_s_120m[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ_s_120m$RAY_s[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ_s_120m$RAYsig_s[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ_s_120m$MEAN_s[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ_s_120m$Rho_s[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ_s_120m,\"C:/Users/Neza/Downloads/tapping/circ_s_120m_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_s_120m.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d560b197",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_120m(file):\n",
    "    circular_120m(file)\n",
    "    \n",
    "    df1 = df_diff_angle_120m(file)\n",
    "    df2 = pd.read_excel('circ_s_120m_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_s_120m.xlsx\")\n",
    "    os.remove(\"circ_s_120m_stat.xlsx\")\n",
    "    \n",
    "    #if df['RAYsig_s'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_s'] = 'RAYsig_s > 0.05'\n",
    "      #  df.at[0, 'Rho_s'] = 'RAYsig_s > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70563d55",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_120m(file):\n",
    "    df = final_circ_120m(file)\n",
    "    \n",
    "    df['abs_diff'] = df['diff_s'].abs()\n",
    "    df['m_diff'] = [np.mean(df['diff_s'])]+['']*(len(df)-1)\n",
    "    df['m_abs'] = [np.mean(df['abs_diff'])]+['']*(len(df)-1)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line <= 28:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'contMTC': first})\n",
    "\n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1acd1695",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_concat_120m(file, directory):\n",
    "    excels = ioi_limits_120m(directory)\n",
    "    \n",
    "    df1 = cont_mtc_120m(file)\n",
    "    df2 = pd.read_excel('df_ioi_120m.xlsx', usecols=lambda x: 'Unnamed' not in x,)\n",
    "    \n",
    "    df2 = df2.drop('all_120m', axis=1)\n",
    "    \n",
    "    frames = [df1, df2]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    os.remove(\"df_ioi_120m.xlsx\")\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7468ee55",
   "metadata": {},
   "source": [
    "## Circular analysis of continuation phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52b64b86",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_filter_120m(file, directory):\n",
    "    df = final_concat_120m(file, directory)\n",
    "    \n",
    "    df['differ'] = df['contMTC'].diff()\n",
    "    first = df['contMTC'].tolist()\n",
    "    second = df['differ'].tolist()\n",
    "    \n",
    "    \n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "    \n",
    "    for vsak in first:\n",
    "        if vsak != 0 and vsak > 20:\n",
    "            prvi = vsak\n",
    "            break\n",
    "    \n",
    "    on = [prvi] + second\n",
    "    \n",
    "    col = second\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 30:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 30:\n",
    "            col[i] = 0\n",
    "        \n",
    "    df1 = pd.DataFrame({'filter_c':col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    df['filtered_c'] = np.where(df['filter_c'] == 0,\n",
    "                             df['filter_c'], df['contMTC'])\n",
    "    \n",
    "    df['filtered_c'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    df = df.drop(['differ', 'filter_c'], axis = 1)\n",
    "    \n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1577b06",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_c_120m(file, directory):\n",
    "    df = cont_mtc_filter_120m(file, directory)\n",
    "    \n",
    "    df['diff_c'] = (pd.merge_asof(df['filtered_c'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered_c', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered_c'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_c'] = (df['diff_c']/0.5)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6df53f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_c_120m(file, directory):\n",
    "    prep = prep_for_r_c_120m(file, directory)\n",
    "    circ_in_r_c_120m(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49b60e6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_c_120m(file, directory):\n",
    "    df = df_diff_angle_c_120m(file, directory)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_c'])\n",
    "        \n",
    "    return df_a.to_excel('angle_c_120m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93a6f319",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Be careful you installed all packages\n",
    "\n",
    "#Excecute R circular analysis and make xlsx file with measurement\n",
    "\n",
    "#Change to right path and name of this files later in code\n",
    "#write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "#circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "\n",
    "def circ_in_r_c_120m(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_c_120m <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_c_120m[1] <- NULL\n",
    "\n",
    "          circ120mc <- data.frame(ID = colnames(angle_c_120m), \n",
    "                               RAY_c = NA,\n",
    "                               RAYsig_c = NA,\n",
    "                               MEAN_c = NA,\n",
    "                               Rho_c = NA)\n",
    "\n",
    "          for(i in 1:length(circ120mc$ID)){\n",
    "            a <- angle_c_120m[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ120mc$RAY_c[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ120mc$RAYsig_c[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ120mc$MEAN_c[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ120mc$Rho_c[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ120mc,\"C:/Users/Neza/Downloads/tapping/circ120mc_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_c_120m.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "104571d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_c_120m(file, directory):\n",
    "    circular_c_120m(file, directory)\n",
    "    \n",
    "    df1 = df_diff_angle_c_120m(file, directory)\n",
    "    df2 = pd.read_excel('circ120mc_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_c_120m.xlsx\")\n",
    "    os.remove(\"circ120mc_stat.xlsx\")\n",
    "    \n",
    "    #if you want the notification if RAYsig is above 0.05, uncomment next three lines\n",
    "\n",
    "    #if df['RAYsig_c'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_c'] = 'RAYsig_c > 0.05'\n",
    "      #  df.at[0, 'Rho_c'] = 'RAYsig_c > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5c64704",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_ioi_filt_120m(file, directory):\n",
    "    df = final_circ_c_120m(file, directory)\n",
    "    \n",
    "    df['Difference'] = df['contMTC'].diff()\n",
    "    first = df['Difference'].tolist()\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < (df['min'].iloc[0]) or vrstica > (df['max'].iloc[0]):\n",
    "            first[i] = 0            \n",
    "            \n",
    "    df1 = pd.DataFrame({'preIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    \n",
    "    col = df['preIOI'].tolist()\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 29:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 29:\n",
    "            col[i] = 0\n",
    "\n",
    "    df1 = pd.DataFrame({'preIOI_29': col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ca26ea8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_ioi_final_120m(file, directory):\n",
    "    df = pre_ioi_filt_120m(file, directory)\n",
    "    df['contMTC'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI_29'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    first = df['preIOI_29'].tolist()\n",
    "    \n",
    "    q1 = np.quantile(first, .25)\n",
    "    q3 = np.quantile(first, .75)\n",
    "    iqr = q3 - q1\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < 0.1 or vrstica < (q1 - (3*iqr)) or vrstica > (q3 + (3*iqr)):\n",
    "            first[i] = 0\n",
    "            \n",
    "            \n",
    "    df1 = pd.DataFrame({'contIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df['contIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fc9746f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_calc_120m(file, directory):\n",
    "    df = cont_ioi_final_120m(file, directory)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['mIOIcont'] = [df['contIOI'].mean()]+['']*(len(df)-1)\n",
    "    df['CVcont'] = [(df['contIOI'].std())/(df['mIOIcont'].iloc[0])]+['']*(len(df)-1)\n",
    "    \n",
    "    df['IOIelemszam'] = [((df['contIOI'] != 0).sum())]+['']*(len(df)-1)\n",
    "    #df['torolni'] = [(df['IOIelemszam'].iloc[0]) - 29]+['']*(len(df)-1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8632964b",
   "metadata": {},
   "source": [
    "# 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74aa5a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_alone_150(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['Difference'] = df.diff()\n",
    "    first = df.iloc[:,0].tolist()\n",
    "    second = df.iloc[:,1].tolist()\n",
    "\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                vrstica2 = float('NaN')\n",
    "                second[i] = vrstica2\n",
    "            \n",
    "    df1 = pd.DataFrame({'ioi':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    df = df.rename(columns={\"ioi\": name})\n",
    "    df = df.iloc[: , 1:]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d85f0074",
   "metadata": {},
   "source": [
    "Add to raw data clean (1.4<x<20.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2d227f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean_150(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line < 1.4 or line > 20.8:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'clean': first})\n",
    "    \n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2d75e57",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_filt10_150(file):\n",
    "    df = ioi_lim_clean_150(file)\n",
    "    \n",
    "    df['diff'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "    \n",
    "    delete = 0\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "            elif vrstica2 != 0 and delete < 10:\n",
    "                second[i] = 0\n",
    "                delete += 1\n",
    "    \n",
    "                           \n",
    "    df1 = pd.DataFrame({'filter10':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b6f4182",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean10_150(file):\n",
    "    df = ioi_lim_filt10_150(file)\n",
    "       \n",
    "    \n",
    "    df['filtered'] = np.where(df['filter10'] == 0,\n",
    "                             df['filter10'], df['clean'])\n",
    "    \n",
    "    df['filtered'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76a6e58f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_prep_150(file):\n",
    "    df = ioi_lim_clean10_150(file)\n",
    "    df = df.drop(['clean', 'diff', 'filter10'], axis=1)\n",
    "    \n",
    "    s = [0]\n",
    "    x = 0\n",
    "    while x < 50:\n",
    "        x += 0.4\n",
    "        s.append(x)\n",
    "\n",
    "    df['REF'] = pd.Series(s)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1c7a5f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_150(file):\n",
    "    df = df_prep_150(file)\n",
    "    \n",
    "    df['diff_s'] = (pd.merge_asof(df['filtered'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_s'] = (df['diff_s']/0.4)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c82ff219",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_files_150(directory):\n",
    "    seznam = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory):\n",
    "        for filename in [f for f in filenames if f.endswith(\"150.csv\")]:\n",
    "            seznam.append(os.path.join(dirpath, filename))\n",
    "            \n",
    "    return seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db72a334",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_frame_150(directory):\n",
    "    \n",
    "    seznam = get_files_150(directory)\n",
    "    li = []    \n",
    "    \n",
    "    for filename in seznam:\n",
    "        df = ioi_lim_alone_150(filename)\n",
    "        li.append(df)\n",
    "\n",
    "    frame = pd.concat(li, axis=1, ignore_index=False)\n",
    "    \n",
    "    return frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fda79326",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_ioi_calc_150(directory):\n",
    "    frame = ioi_frame_150(directory)\n",
    "    frame['combined']= frame.values.tolist()\n",
    "    li = []\n",
    "\n",
    "    for row in frame['combined']:\n",
    "        for vsak in row:\n",
    "            li.append(vsak)\n",
    "\n",
    "    new_array = [x for x in li if math.isnan(x) == False]\n",
    "    se = pd.Series(new_array)\n",
    "    \n",
    "    df_ioi = pd.DataFrame([new_array])\n",
    "    df_ioi = df_ioi.T\n",
    "    df_ioi['all_150'] = pd.DataFrame(data=se)\n",
    "    df_ioi = df_ioi.iloc[: , 1:]\n",
    "    \n",
    "    return df_ioi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8543993",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_limits_150(directory):\n",
    "    frame = ioi_frame_150(directory)\n",
    "    df_ioi = list_ioi_calc_150(directory)\n",
    "    \n",
    "    df_ioi['mean'] = [(df_ioi['all_150'].mean())]+['']*(len(df_ioi)-1)\n",
    "    frame['mean'] = df_ioi['mean']\n",
    "    \n",
    "    df_ioi['std'] = [(df_ioi['all_150'].std())]+['']*(len(df_ioi)-1)\n",
    "    frame['std'] = df_ioi['std']\n",
    "    \n",
    "    df_ioi['q1'] = [(df_ioi['all_150'].quantile(.25, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q1'] = df_ioi['q1']\n",
    "    \n",
    "    df_ioi['q3'] = [(df_ioi['all_150'].quantile(.75, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q3'] = df_ioi['q3']\n",
    "    \n",
    "    df_ioi['IQR'] = [(df_ioi['q3'].iloc[0] - df_ioi['q1'].iloc[0])]+['']*(len(df_ioi)-1)\n",
    "    frame['IQR'] = df_ioi['IQR']\n",
    "    \n",
    "    df_ioi['min'] = [(df_ioi['q1'].iloc[0] - (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['min'] = df_ioi['min']\n",
    "    \n",
    "    df_ioi['max'] = [(df_ioi['q3'].iloc[0] + (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['max'] = df_ioi['max']\n",
    "    \n",
    "    return df_ioi.to_excel('df_ioi_150.xlsx'), frame.to_excel('IOI_filter_150.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a46f0cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_150(file):\n",
    "    prep = prep_for_r_150(file)\n",
    "    circ_in_r_150(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48937748",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_150(file):\n",
    "    df = df_diff_angle_150(file)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_s'])\n",
    "        \n",
    "    return df_a.to_excel('angle_s_150.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94f55309",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Change to the right path, where should be excel files made\n",
    "\n",
    "def circ_in_r_150(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_s_150 <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_s_150[1] <- NULL\n",
    "\n",
    "          circs150 <- data.frame(ID = colnames(angle_s_150), \n",
    "                               RAY_s = NA,\n",
    "                               RAYsig_s = NA,\n",
    "                               MEAN_s = NA,\n",
    "                               Rho_s = NA)\n",
    "\n",
    "          for(i in 1:length(circs150$ID)){\n",
    "            a <- angle_s_150[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circs150$RAY_s[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circs150$RAYsig_s[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circs150$MEAN_s[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circs150$Rho_s[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circs150,\"C:/Users/Neza/Downloads/tapping/circs150_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_s_150.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "479df797",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_150(file):\n",
    "    circular_150(file)\n",
    "    \n",
    "    df1 = df_diff_angle_150(file)\n",
    "    df2 = pd.read_excel('circs150_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_s_150.xlsx\")\n",
    "    os.remove(\"circs150_stat.xlsx\")\n",
    "    \n",
    "   # if df['RAYsig'].iloc[0] > 0.05:\n",
    "    #    df.at[0, 'MEAN'] = 'RAYsig > 0.05'\n",
    "     #   df.at[0, 'Rho'] = 'RAYsig > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77e0d5e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_150(file):\n",
    "    df = final_circ_150(file)\n",
    "    \n",
    "    df['abs_diff'] = df['diff_s'].abs()\n",
    "    df['m_diff'] = [np.mean(df['diff_s'])]+['']*(len(df)-1)\n",
    "    df['m_abs'] = [np.mean(df['abs_diff'])]+['']*(len(df)-1)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line <= 20.8:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'contMTC': first})\n",
    "\n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d02858c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_concat_150(file, directory):\n",
    "    excels = ioi_limits_150(directory)\n",
    "    \n",
    "    df1 = cont_mtc_150(file)\n",
    "    df2 = pd.read_excel('df_ioi_150.xlsx', usecols=lambda x: 'Unnamed' not in x,)\n",
    "    \n",
    "    df2 = df2.drop('all_150', axis=1)\n",
    "    \n",
    "    frames = [df1, df2]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    os.remove(\"df_ioi_150.xlsx\")\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d4f1e4f",
   "metadata": {},
   "source": [
    "## Circular analysis of continuation phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "636eccee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_filter_150(file, directory):\n",
    "    df = final_concat_150(file, directory)\n",
    "    \n",
    "    df['differ'] = df['contMTC'].diff()\n",
    "    first = df['contMTC'].tolist()\n",
    "    second = df['differ'].tolist()\n",
    "    \n",
    "    \n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "    \n",
    "    for vsak in first:\n",
    "        if vsak != 0 and vsak > 20:\n",
    "            prvi = vsak\n",
    "            break\n",
    "    \n",
    "    on = [prvi] + second\n",
    "    \n",
    "    col = second\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 30:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 30:\n",
    "            col[i] = 0\n",
    "        \n",
    "    df1 = pd.DataFrame({'filter_c':col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    df['filtered_c'] = np.where(df['filter_c'] == 0,\n",
    "                             df['filter_c'], df['contMTC'])\n",
    "    \n",
    "    df['filtered_c'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    df = df.drop(['differ', 'filter_c'], axis = 1)\n",
    "    \n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac1ddb61",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_c_150(file, directory):\n",
    "    df = cont_mtc_filter_150(file, directory)\n",
    "    \n",
    "    df['diff_c'] = (pd.merge_asof(df['filtered_c'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered_c', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered_c'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_c'] = (df['diff_c']/0.4)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfe65e2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_c_150(file, directory):\n",
    "    prep = prep_for_r_c_150(file, directory)\n",
    "    circ_in_r_c_150(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22515c8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_c_150(file, directory):\n",
    "    df = df_diff_angle_c_150(file, directory)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_c'])\n",
    "        \n",
    "    return df_a.to_excel('angle_c_150.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5207d52d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Be careful you installed all packages\n",
    "\n",
    "#Excecute R circular analysis and make xlsx file with measurement\n",
    "\n",
    "#Change to right path and name of this files later in code\n",
    "#write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "#circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "\n",
    "def circ_in_r_c_150(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_c_150 <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_c_150[1] <- NULL\n",
    "\n",
    "          circ150c <- data.frame(ID = colnames(angle_c_150), \n",
    "                               RAY_c = NA,\n",
    "                               RAYsig_c = NA,\n",
    "                               MEAN_c = NA,\n",
    "                               Rho_c = NA)\n",
    "\n",
    "          for(i in 1:length(circ150c$ID)){\n",
    "            a <- angle_c_150[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ150c$RAY_c[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ150c$RAYsig_c[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ150c$MEAN_c[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ150c$Rho_c[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ150c,\"C:/Users/Neza/Downloads/tapping/circ150c_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_c_150.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f89c752",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_c_150(file, directory):\n",
    "    circular_c_150(file, directory)\n",
    "    \n",
    "    df1 = df_diff_angle_c_150(file, directory)\n",
    "    df2 = pd.read_excel('circ150c_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_c_150.xlsx\")\n",
    "    os.remove(\"circ150c_stat.xlsx\")\n",
    "    \n",
    "    #if you want the notification if RAYsig is above 0.05, uncomment next three lines\n",
    "\n",
    "    #if df['RAYsig_c'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_c'] = 'RAYsig_c > 0.05'\n",
    "      #  df.at[0, 'Rho_c'] = 'RAYsig_c > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "589c2a2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_ioi_filt_150(file, directory):\n",
    "    df = final_circ_c_150(file, directory)\n",
    "    \n",
    "    df['Difference'] = df['contMTC'].diff()\n",
    "    first = df['Difference'].tolist()\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < (df['min'].iloc[0]) or vrstica > (df['max'].iloc[0]):\n",
    "            first[i] = 0            \n",
    "            \n",
    "    df1 = pd.DataFrame({'preIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    \n",
    "    col = df['preIOI'].tolist()\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 29:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 29:\n",
    "            col[i] = 0\n",
    "\n",
    "    df1 = pd.DataFrame({'preIOI_29': col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fce23c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_ioi_final_150(file, directory):\n",
    "    df = pre_ioi_filt_150(file, directory)\n",
    "    df['contMTC'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI_29'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    first = df['preIOI_29'].tolist()\n",
    "    \n",
    "    q1 = np.quantile(first, .25)\n",
    "    q3 = np.quantile(first, .75)\n",
    "    iqr = q3 - q1\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < 0.1 or vrstica < (q1 - (3*iqr)) or vrstica > (q3 + (3*iqr)):\n",
    "            first[i] = 0\n",
    "            \n",
    "            \n",
    "    df1 = pd.DataFrame({'contIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df['contIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0942b2cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_calc_150(file, directory):\n",
    "    df = cont_ioi_final_150(file, directory)\n",
    "    \n",
    "    df['mIOIcont'] = [df['contIOI'].mean()]+['']*(len(df)-1)\n",
    "    df['CVcont'] = [(df['contIOI'].std())/(df['mIOIcont'].iloc[0])]+['']*(len(df)-1)\n",
    "    \n",
    "    df['IOIelemszam'] = [((df['contIOI'] != 0).sum())]+['']*(len(df)-1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8cedead",
   "metadata": {},
   "source": [
    "# 150m - Functions on one sheet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8afb4db5",
   "metadata": {},
   "source": [
    "Everything same as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0de33111",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_alone_150m(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    name = get_name2(file)\n",
    "    \n",
    "    df['Difference'] = df.diff()\n",
    "    first = df.iloc[:,0].tolist()\n",
    "    second = df.iloc[:,1].tolist()\n",
    "\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                vrstica2 = float('NaN')\n",
    "                second[i] = vrstica2\n",
    "            \n",
    "    df1 = pd.DataFrame({'ioi':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    df = df.rename(columns={\"ioi\": name})\n",
    "    df = df.iloc[: , 1:]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ab4b90e",
   "metadata": {},
   "source": [
    "Add to raw data clean (1.4<x<20.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35bac59a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean_150m(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line < 1.4 or line > 20.8:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'clean': first})\n",
    "    \n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61568bf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_filt10_150m(file):\n",
    "    df = ioi_lim_clean_150m(file)\n",
    "    \n",
    "    df['diff'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "    \n",
    "    delete = 0\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "            elif vrstica2 != 0 and delete < 10:\n",
    "                second[i] = 0\n",
    "                delete += 1\n",
    "    \n",
    "                           \n",
    "    df1 = pd.DataFrame({'filter10':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1e5240d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean10_150m(file):\n",
    "    df = ioi_lim_filt10_150m(file)\n",
    "       \n",
    "    \n",
    "    df['filtered'] = np.where(df['filter10'] == 0,\n",
    "                             df['filter10'], df['clean'])\n",
    "    \n",
    "    df['filtered'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b49e865",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_prep_150m(file):\n",
    "    df = ioi_lim_clean10_150m(file)\n",
    "    df = df.drop(['clean', 'diff', 'filter10'], axis=1)\n",
    "    \n",
    "    s = [0]\n",
    "    x = 0\n",
    "    while x < 50:\n",
    "        x += 0.4\n",
    "        s.append(x)\n",
    "\n",
    "    df['REF'] = pd.Series(s)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "436db2ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_150m(file):\n",
    "    df = df_prep_150m(file)\n",
    "    \n",
    "    df['diff_s'] = (pd.merge_asof(df['filtered'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_s'] = (df['diff_s']/0.4)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a65555c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_files_150m(directory):\n",
    "    seznam = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory):\n",
    "        for filename in [f for f in filenames if f.endswith(\"150m.csv\")]:\n",
    "            seznam.append(os.path.join(dirpath, filename))\n",
    "            \n",
    "    return seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2385fb8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_frame_150m(directory):\n",
    "    \n",
    "    seznam = get_files_150m(directory)\n",
    "    li = []    \n",
    "    \n",
    "    for filename in seznam:\n",
    "        df = ioi_lim_alone_150m(filename)\n",
    "        li.append(df)\n",
    "\n",
    "    frame = pd.concat(li, axis=1, ignore_index=False)\n",
    "    \n",
    "    return frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49298e27",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_ioi_calc_150m(directory):\n",
    "    frame = ioi_frame_150m(directory)\n",
    "    frame['combined']= frame.values.tolist()\n",
    "    li = []\n",
    "\n",
    "    for row in frame['combined']:\n",
    "        for vsak in row:\n",
    "            li.append(vsak)\n",
    "\n",
    "    new_array = [x for x in li if math.isnan(x) == False]\n",
    "    se = pd.Series(new_array)\n",
    "    \n",
    "    df_ioi = pd.DataFrame([new_array])\n",
    "    df_ioi = df_ioi.T\n",
    "    df_ioi['all_150m'] = pd.DataFrame(data=se)\n",
    "    df_ioi = df_ioi.iloc[: , 1:]\n",
    "    \n",
    "    return df_ioi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09c8a101",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_limits_150m(directory):\n",
    "    frame = ioi_frame_150m(directory)\n",
    "    df_ioi = list_ioi_calc_150m(directory)\n",
    "    \n",
    "    df_ioi['mean'] = [(df_ioi['all_150m'].mean())]+['']*(len(df_ioi)-1)\n",
    "    frame['mean'] = df_ioi['mean']\n",
    "    \n",
    "    df_ioi['std'] = [(df_ioi['all_150m'].std())]+['']*(len(df_ioi)-1)\n",
    "    frame['std'] = df_ioi['std']\n",
    "    \n",
    "    df_ioi['q1'] = [(df_ioi['all_150m'].quantile(.25, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q1'] = df_ioi['q1']\n",
    "    \n",
    "    df_ioi['q3'] = [(df_ioi['all_150m'].quantile(.75, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q3'] = df_ioi['q3']\n",
    "    \n",
    "    df_ioi['IQR'] = [(df_ioi['q3'].iloc[0] - df_ioi['q1'].iloc[0])]+['']*(len(df_ioi)-1)\n",
    "    frame['IQR'] = df_ioi['IQR']\n",
    "    \n",
    "    df_ioi['min'] = [(df_ioi['q1'].iloc[0] - (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['min'] = df_ioi['min']\n",
    "    \n",
    "    df_ioi['max'] = [(df_ioi['q3'].iloc[0] + (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['max'] = df_ioi['max']\n",
    "    \n",
    "    return df_ioi.to_excel('df_ioi_150m.xlsx'), frame.to_excel('IOI_filter_150m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e3236f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_150m(file):\n",
    "    prep = prep_for_r_150m(file)\n",
    "    circ_in_r_150m(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1b4eaa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_150m(file):\n",
    "    df = df_diff_angle_150m(file)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_s'])\n",
    "        \n",
    "    return df_a.to_excel('angle_s_150m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8cf0348",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Change to the right path, where should be excel files made\n",
    "\n",
    "def circ_in_r_150m(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_s_150m <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_s_150m[1] <- NULL\n",
    "\n",
    "          circs150m <- data.frame(ID = colnames(angle_s_150m), \n",
    "                               RAY_s = NA,\n",
    "                               RAYsig_s = NA,\n",
    "                               MEAN_s = NA,\n",
    "                               Rho_s = NA)\n",
    "\n",
    "          for(i in 1:length(circs150m$ID)){\n",
    "            a <- angle_s_150m[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circs150m$RAY_s[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circs150m$RAYsig_s[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circs150m$MEAN_s[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circs150m$Rho_s[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circs150m,\"C:/Users/Neza/Downloads/tapping/circs150m_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_s_150m.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecf77826",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_150m(file):\n",
    "    circular_150m(file)\n",
    "    \n",
    "    df1 = df_diff_angle_150m(file)\n",
    "    df2 = pd.read_excel('circs150m_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_s_150m.xlsx\")\n",
    "    os.remove(\"circs150m_stat.xlsx\")\n",
    "    \n",
    "   # if df['RAYsig_s'].iloc[0] > 0.05:\n",
    "    #    df.at[0, 'MEAN_s'] = 'RAYsig_s > 0.05'\n",
    "     #   df.at[0, 'Rho_s'] = 'RAYsig_s > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72bcea4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_150m(file):\n",
    "    df = final_circ_150m(file)\n",
    "    \n",
    "    df['abs_diff'] = df['diff_s'].abs()\n",
    "    df['m_diff'] = [np.mean(df['diff_s'])]+['']*(len(df)-1)\n",
    "    df['m_abs'] = [np.mean(df['abs_diff'])]+['']*(len(df)-1)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line <= 20.8:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'contMTC': first})\n",
    "\n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86b67b0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_concat_150m(file, directory):\n",
    "    excels = ioi_limits_150m(directory)\n",
    "    \n",
    "    df1 = cont_mtc_150m(file)\n",
    "    df2 = pd.read_excel('df_ioi_150m.xlsx', usecols=lambda x: 'Unnamed' not in x,)\n",
    "    \n",
    "    df2 = df2.drop('all_150m', axis=1)\n",
    "    \n",
    "    frames = [df1, df2]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    os.remove(\"df_ioi_150m.xlsx\")\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b2b2f5f",
   "metadata": {},
   "source": [
    "## Circular analysis of continuation phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f820667",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_mtc_filter_150m(file, directory):\n",
    "    df = final_concat_150m(file, directory)\n",
    "    \n",
    "    df['differ'] = df['contMTC'].diff()\n",
    "    first = df['contMTC'].tolist()\n",
    "    second = df['differ'].tolist()\n",
    "    \n",
    "    \n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "    \n",
    "    for vsak in first:\n",
    "        if vsak != 0 and vsak > 20:\n",
    "            prvi = vsak\n",
    "            break\n",
    "    \n",
    "    on = [prvi] + second\n",
    "    \n",
    "    col = second\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 30:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 30:\n",
    "            col[i] = 0\n",
    "        \n",
    "    df1 = pd.DataFrame({'filter_c':col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    df['filtered_c'] = np.where(df['filter_c'] == 0,\n",
    "                             df['filter_c'], df['contMTC'])\n",
    "    \n",
    "    df['filtered_c'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    df = df.drop(['differ', 'filter_c'], axis = 1)\n",
    "    \n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83fa53ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_diff_angle_c_150m(file, directory):\n",
    "    df = cont_mtc_filter_150m(file, directory)\n",
    "    \n",
    "    df['diff_c'] = (pd.merge_asof(df['filtered_c'].dropna().sort_values().reset_index(),\n",
    "                                df[['REF']].dropna().sort_values('REF'),\n",
    "                                left_on='filtered_c', right_on='REF', direction='nearest')\n",
    "                    .set_index('index')['REF'].rsub(df['filtered_c'])\n",
    "                  )\n",
    "    \n",
    "    df['angle_c'] = (df['diff_c']/0.4)*360\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cace3de",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circular_c_150m(file, directory):\n",
    "    prep = prep_for_r_c_150m(file, directory)\n",
    "    circ_in_r_c_150m(prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "036d2306",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_for_r_c_150m(file, directory):\n",
    "    df = df_diff_angle_c_150m(file, directory)\n",
    "    name = get_name1(file)\n",
    "\n",
    "    df_a = df.filter(['angle_c'])\n",
    "        \n",
    "    return df_a.to_excel('angle_c_150m.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7c27b0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Be careful you installed all packages\n",
    "\n",
    "#Excecute R circular analysis and make xlsx file with measurement\n",
    "\n",
    "#Change to right path and name of this files later in code\n",
    "#write.xlsx(circ80,\"C:/Users/Neza/Downloads/tapping/circ80_stat.xlsx\")\n",
    "#circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_80.xlsx\")\n",
    "\n",
    "def circ_in_r_c_150m(prep):\n",
    "\n",
    "    robjects.r('''\n",
    "        circ_anal <- function (xlsx_file) {\n",
    "          library(readxl)\n",
    "          library(circular)\n",
    "          library(openxlsx)\n",
    "          library(readr)\n",
    "          library(rlang)\n",
    "\n",
    "          angle_c_150m <- read_excel(xlsx_file)\n",
    "\n",
    "          angle_c_150m[1] <- NULL\n",
    "\n",
    "          circ150mc <- data.frame(ID = colnames(angle_c_150m), \n",
    "                               RAY_c = NA,\n",
    "                               RAYsig_c = NA,\n",
    "                               MEAN_c = NA,\n",
    "                               Rho_c = NA)\n",
    "\n",
    "          for(i in 1:length(circ150mc$ID)){\n",
    "            a <- angle_c_150m[,i]\n",
    "            a_circ <- circular(a, units = \"degrees\", zero = circular(pi/2), rotation = \"clock\")\n",
    "            circ150mc$RAY_c[i] <- rayleigh.test(a_circ)$statistic\n",
    "            circ150mc$RAYsig_c[i] <- rayleigh.test(a_circ)$p.value\n",
    "            circ150mc$MEAN_c[i] <- mean.circular(a_circ, na.rm = TRUE)\n",
    "            circ150mc$Rho_c[i] <- rho.circular(a_circ, na.rm = TRUE)\n",
    "\n",
    "          }\n",
    "\n",
    "\n",
    "          write.xlsx(circ150mc,\"C:/Users/Neza/Downloads/tapping/circ150mc_stat.xlsx\")\n",
    "\n",
    "        }\n",
    "\n",
    "        circ_anal(\"C:/Users/Neza/Downloads/tapping/angle_c_150m.xlsx\")\n",
    "    ''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78a0fa1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_circ_c_150m(file, directory):\n",
    "    circular_c_150m(file, directory)\n",
    "    \n",
    "    df1 = df_diff_angle_c_150m(file, directory)\n",
    "    df2 = pd.read_excel('circ150mc_stat.xlsx')\n",
    "\n",
    "    df = pd.concat([df1, df2], axis = 1)\n",
    "    df = df.drop('ID', axis=1)\n",
    "\n",
    "    os.remove(\"angle_c_150m.xlsx\")\n",
    "    os.remove(\"circ150mc_stat.xlsx\")\n",
    "    \n",
    "    #if you want the notification if RAYsig is above 0.05, uncomment next three lines\n",
    "\n",
    "    #if df['RAYsig_c'].iloc[0] > 0.05:\n",
    "     #   df.at[0, 'MEAN_c'] = 'RAYsig_c > 0.05'\n",
    "      #  df.at[0, 'Rho_c'] = 'RAYsig_c > 0.05'\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30635cc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_ioi_filt_150m(file, directory):\n",
    "    df = final_circ_c_150m(file, directory)\n",
    "    \n",
    "    df['Difference'] = df['contMTC'].diff()\n",
    "    first = df['Difference'].tolist()\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < (df['min'].iloc[0]) or vrstica > (df['max'].iloc[0]):\n",
    "            first[i] = 0            \n",
    "            \n",
    "    df1 = pd.DataFrame({'preIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop('Difference', axis = 1)\n",
    "    \n",
    "    col = df['preIOI'].tolist()\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st <= 29:\n",
    "            st += 1\n",
    "        elif line != 0 and st > 29:\n",
    "            col[i] = 0\n",
    "\n",
    "    df1 = pd.DataFrame({'preIOI_29': col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c8e2baf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cont_ioi_final_150m(file, directory):\n",
    "    df = pre_ioi_filt_150m(file, directory)\n",
    "    df['contMTC'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI_29'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    first = df['preIOI_29'].tolist()\n",
    "    \n",
    "    q1 = np.quantile(first, .25)\n",
    "    q3 = np.quantile(first, .75)\n",
    "    iqr = q3 - q1\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < 0.1 or vrstica < (q1 - (3*iqr)) or vrstica > (q3 + (3*iqr)):\n",
    "            first[i] = 0\n",
    "            \n",
    "            \n",
    "    df1 = pd.DataFrame({'contIOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df['contIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2c828fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_calc_150m(file, directory):\n",
    "    df = cont_ioi_final_150m(file, directory)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['mIOIcont'] = [df['contIOI'].mean()]+['']*(len(df)-1)\n",
    "    df['CVcont'] = [(df['contIOI'].std())/(df['mIOIcont'].iloc[0])]+['']*(len(df)-1)\n",
    "    \n",
    "    df['IOIelemszam'] = [((df['contIOI'] != 0).sum())]+['']*(len(df)-1)\n",
    "    #df['torolni'] = [(df['IOIelemszam'].iloc[0]) - 29]+['']*(len(df)-1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "509cab6c",
   "metadata": {},
   "source": [
    "# SMT"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b901826",
   "metadata": {},
   "source": [
    "For SMT task on one sheet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0aa86e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Read file and delete after 30 sec\n",
    "def ioi_lim_clean_SMT(file):\n",
    "    df = read_edit_csv3(file)\n",
    "    \n",
    "    first = df.iloc[:,0].tolist()\n",
    "    for i, line in enumerate(first):\n",
    "        if line > 30:\n",
    "            first[i] = 0\n",
    "    df1 = pd.DataFrame({'clean': first})\n",
    "    \n",
    "    frames = [df,df1]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43e0eed5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Filter 0.1, prepare for IOI limits file\n",
    "\n",
    "def ioi_lim_alone_SMT(file):\n",
    "    df = ioi_lim_clean_SMT(file)\n",
    "    name = get_name2(file)\n",
    "    \n",
    "    df['Difference'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                vrstica2 = float('NaN')\n",
    "                second[i] = vrstica2\n",
    "            \n",
    "    df1 = pd.DataFrame({'ioi':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df = df.drop(['Difference', 'clean'], axis = 1)\n",
    "    df = df.rename(columns={\"ioi\": name})\n",
    "    df = df.iloc[: , 1:]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "547fb419",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Filter 10 and 0.1\n",
    "\n",
    "def ioi_lim_filt10_SMT(file):\n",
    "    df = ioi_lim_clean_SMT(file)\n",
    "    \n",
    "    df['diff'] = df['clean'].diff()\n",
    "    first = df.iloc[:,1].tolist()\n",
    "    second = df.iloc[:,2].tolist()\n",
    "    \n",
    "    delete = 0\n",
    "    for vrstica1 in first:\n",
    "        for i, vrstica2 in enumerate(second):\n",
    "            if vrstica2 == vrstica1 or vrstica2 < 0.1:\n",
    "                second[i] = 0\n",
    "            elif vrstica2 != 0 and delete < 10:\n",
    "                second[i] = 0\n",
    "                delete += 1\n",
    "    \n",
    "                           \n",
    "    df1 = pd.DataFrame({'preIOI':second})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28b87d06",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_lim_clean10_SMT(file):\n",
    "    df = ioi_lim_filt10_SMT(file)\n",
    "    \n",
    "    df['preIOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    df = df.drop(['clean', 'diff'], axis = 1)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f853191",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_files_SMT(directory):\n",
    "    seznam = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory):\n",
    "        for filename in [f for f in filenames if f.endswith(\"SMT.csv\")]:\n",
    "            seznam.append(os.path.join(dirpath, filename))\n",
    "            \n",
    "    return seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1d41f8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_frame_SMT(directory):\n",
    "    \n",
    "    seznam = get_files_SMT(directory)\n",
    "    li = []    \n",
    "    \n",
    "    for filename in seznam:\n",
    "        df = ioi_lim_alone_SMT(filename)\n",
    "        li.append(df)\n",
    "\n",
    "    frame = pd.concat(li, axis=1, ignore_index=False)\n",
    "    \n",
    "    return frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa106502",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_ioi_calc_SMT(directory):\n",
    "    frame = ioi_frame_SMT(directory)\n",
    "    frame['combined']= frame.values.tolist()\n",
    "    li = []\n",
    "\n",
    "    for row in frame['combined']:\n",
    "        for vsak in row:\n",
    "            li.append(vsak)\n",
    "\n",
    "    new_array = [x for x in li if math.isnan(x) == False]\n",
    "    se = pd.Series(new_array)\n",
    "    \n",
    "    df_ioi = pd.DataFrame([new_array])\n",
    "    df_ioi = df_ioi.T\n",
    "    df_ioi['all_SMT'] = pd.DataFrame(data=se)\n",
    "    df_ioi = df_ioi.iloc[: , 1:]\n",
    "    \n",
    "    return df_ioi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a2c17df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ioi_limits_SMT(directory):\n",
    "    frame = ioi_frame_SMT(directory)\n",
    "    df_ioi = list_ioi_calc_SMT(directory)\n",
    "    \n",
    "    df_ioi['mean'] = [(df_ioi['all_SMT'].mean())]+['']*(len(df_ioi)-1)\n",
    "    frame['mean'] = df_ioi['mean']\n",
    "    \n",
    "    df_ioi['std'] = [(df_ioi['all_SMT'].std())]+['']*(len(df_ioi)-1)\n",
    "    frame['std'] = df_ioi['std']\n",
    "    \n",
    "    df_ioi['q1'] = [(df_ioi['all_SMT'].quantile(.25, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q1'] = df_ioi['q1']\n",
    "    \n",
    "    df_ioi['q3'] = [(df_ioi['all_SMT'].quantile(.75, interpolation=\"nearest\"))]+['']*(len(df_ioi)-1)\n",
    "    frame['q3'] = df_ioi['q3']\n",
    "    \n",
    "    df_ioi['IQR'] = [(df_ioi['q3'].iloc[0] - df_ioi['q1'].iloc[0])]+['']*(len(df_ioi)-1)\n",
    "    frame['IQR'] = df_ioi['IQR']\n",
    "    \n",
    "    df_ioi['min'] = [(df_ioi['q1'].iloc[0] - (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['min'] = df_ioi['min']\n",
    "    \n",
    "    df_ioi['max'] = [(df_ioi['q3'].iloc[0] + (3*(df_ioi['IQR'].iloc[0])))]+['']*(len(df_ioi)-1)\n",
    "    frame['max'] = df_ioi['max']\n",
    "    \n",
    "    return df_ioi.to_excel('df_ioi_SMT.xlsx'), frame.to_excel('IOI_filter_SMT.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81b3aac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_concat_SMT(file, directory):\n",
    "    excels = ioi_limits_SMT(directory)\n",
    "    \n",
    "    df1 = ioi_lim_clean10_SMT(file)\n",
    "    df2 = pd.read_excel('df_ioi_SMT.xlsx', usecols=lambda x: 'Unnamed' not in x,)\n",
    "    \n",
    "    df2 = df2.drop('all_SMT', axis=1)\n",
    "    \n",
    "    frames = [df1, df2]\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    os.remove(\"df_ioi_SMT.xlsx\")\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02f38a0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_ioi_filt_SMT(file, directory):\n",
    "    df = final_concat_SMT(file, directory)\n",
    "    \n",
    "    first = df['preIOI'].tolist()\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < (df['min'].iloc[0]) or vrstica > (df['max'].iloc[0]):\n",
    "            first[i] = 0            \n",
    "            \n",
    "    df1 = pd.DataFrame({'preIOI2': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    df['preIOI2'] = df['preIOI2'].fillna(0)\n",
    "    col = df['preIOI2'].tolist()\n",
    "    st = 0\n",
    "\n",
    "    for i, line in enumerate(col):\n",
    "        if line != 0 and st < 39:\n",
    "            st += 1\n",
    "        elif line != 0 and st >= 39:\n",
    "            col[i] = 0\n",
    "\n",
    "    df1 = pd.DataFrame({'preIOI_39': col})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dacf7b11",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Apply Q filters and 39 taps\n",
    "\n",
    "def cont_ioi_final_SMT(file, directory):\n",
    "    df = pre_ioi_filt_SMT(file, directory)\n",
    "    df['preIOI2'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    df['preIOI_39'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    first = df['preIOI_39'].tolist()\n",
    "    \n",
    "    q1 = np.quantile(first, .25)\n",
    "    q3 = np.quantile(first, .75)\n",
    "    iqr = q3 - q1\n",
    "    \n",
    "    for i, vrstica in enumerate(first):\n",
    "        if vrstica < 0.1 or vrstica < (q1 - (3*iqr)) or vrstica > (q3 + (3*iqr)):\n",
    "            first[i] = 0\n",
    "            \n",
    "            \n",
    "    df1 = pd.DataFrame({'IOI': first})\n",
    "    frames = [df,df1]\n",
    "\n",
    "    df = pd.concat(frames, axis=1)\n",
    "    df['IOI'].replace(to_replace = 0, value = float('NaN'), inplace=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b0cf6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_calc_SMT(file, directory):\n",
    "    df = cont_ioi_final_SMT(file, directory)\n",
    "    name = get_name1(file)\n",
    "    \n",
    "    df['mSMT'] = [df['IOI'].mean()]+['']*(len(df)-1)\n",
    "    df['CV'] = [(df['IOI'].std())/(df['mSMT'].iloc[0])]+['']*(len(df)-1)\n",
    "    \n",
    "    df['IOIelemszam'] = [((df['IOI'] != 0).sum())]+['']*(len(df)-1)\n",
    "    #df['torolni'] = [(df['IOIelemszam'].iloc[0]) - 29]+['']*(len(df)-1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1681ef99",
   "metadata": {},
   "source": [
    "# Merged dataframes - reading through folders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38e69d24",
   "metadata": {},
   "source": [
    "Make all measurements for one participant"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e29a109",
   "metadata": {},
   "source": [
    "Goes through folder with participants folders and output all excels."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebef5b21",
   "metadata": {},
   "source": [
    "### Final code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "884d6b62",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final(directory):\n",
    "    st = time.time()\n",
    "    st1 = time.process_time()\n",
    "    \n",
    "    seznam80 = []\n",
    "    seznam80m = []\n",
    "    seznam120 = []\n",
    "    seznam120m = []\n",
    "    seznam150 = []\n",
    "    seznam150m = []\n",
    "    seznamSMT = []\n",
    "    dirp = []\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "            for filename in [f for f in filenames if f.endswith(\"80.csv\")]: #search for all 80 files\n",
    "                seznam80.append(os.path.join(dirpath, filename))\n",
    "                dirp.append(dirpath)\n",
    "\n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "            for filename in [f for f in filenames if f.endswith(\"80m.csv\")]: #search for all 80m files\n",
    "                seznam80m.append(os.path.join(dirpath, filename))\n",
    "    \n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "            for filename in [f for f in filenames if f.endswith(\"120.csv\")]: #search for all 120 files\n",
    "                seznam120.append(os.path.join(dirpath, filename))\n",
    "    \n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "            for filename in [f for f in filenames if f.endswith(\"120m.csv\")]: #search for all 120m files\n",
    "                seznam120m.append(os.path.join(dirpath, filename))\n",
    "                \n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "            for filename in [f for f in filenames if f.endswith(\"150.csv\")]: #search for all 150 files\n",
    "                seznam150.append(os.path.join(dirpath, filename))\n",
    "    \n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "            for filename in [f for f in filenames if f.endswith(\"150m.csv\")]: #search for all 150m files\n",
    "                seznam150m.append(os.path.join(dirpath, filename))\n",
    "    \n",
    "    for dirpath, dirnames, filenames in os.walk(directory): #directory with all folders of participants\n",
    "            for filename in [f for f in filenames if f.endswith(\"SMT.csv\")]: #search for all SMT files\n",
    "                seznamSMT.append(os.path.join(dirpath, filename))\n",
    "\n",
    "\n",
    "    for vsak80, vsak80m, vsak120, vsak120m, vsak150, vsak150m, vsakSMT, pot in zip(seznam80, seznam80m, seznam120, seznam120m, seznam150, seznam150m, seznamSMT, dirp):\n",
    "            path = pot + '_all_anal.xlsx'\n",
    "\n",
    "            file1 = vsak80\n",
    "            df1 = all_calc_80(file1, directory)\n",
    "\n",
    "            file2 = vsak80m\n",
    "            df2 = all_calc_80m(file2, directory)\n",
    "            \n",
    "            file3 = vsak120\n",
    "            df3 = all_calc_120(file3, directory)\n",
    "\n",
    "            file4 = vsak120m\n",
    "            df4 = all_calc_120m(file4, directory)\n",
    "            \n",
    "            file5 = vsak150\n",
    "            df5 = all_calc_150(file5, directory)\n",
    "\n",
    "            file6 = vsak150m\n",
    "            df6 = all_calc_150m(file6, directory)\n",
    "            \n",
    "            file7 = vsakSMT\n",
    "            df7 = all_calc_SMT(file7, directory)\n",
    "\n",
    "            writer = pd.ExcelWriter(path, engine = 'xlsxwriter')\n",
    "            df1.to_excel(writer, sheet_name = '80')\n",
    "            df2.to_excel(writer, sheet_name = '80m')\n",
    "            df3.to_excel(writer, sheet_name = '120')\n",
    "            df4.to_excel(writer, sheet_name = '120m')\n",
    "            df5.to_excel(writer, sheet_name = '150')\n",
    "            df6.to_excel(writer, sheet_name = '150m')\n",
    "            df7.to_excel(writer, sheet_name = 'SMT')\n",
    "            writer.close()\n",
    "    \n",
    "    elapsed_time = time.time() - st\n",
    "    et = time.process_time()\n",
    "    res = et - st1\n",
    "    \n",
    "    return print('Execution time:', time.strftime(\"%H:%M:%S\", time.gmtime(elapsed_time)), #tells you total elapsed time\n",
    "                 '; Execution CPU:', time.strftime(\"%H:%M:%S\", time.gmtime(res))) #tells you only CPU time, without waiting for resources\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80f3e794",
   "metadata": {},
   "source": [
    "# RUN"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "188267de",
   "metadata": {},
   "source": [
    "Here you can test code if you changed all paths in R code and install, import all packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "573c6c1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "directory = input('Write name of directory where you have participants folders with csv files: ')\n",
    "final(directory)"
   ]
  }
 ],
 "metadata": {
  "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}