Experiment 2. (A) Preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data import and preprocessing for Experiment 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_folder= 'Experiment 2. Illusory Triangle and Common Region'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extracting finger-onset asynchrony: response time brackets for two- and three-target disappearance and appearance events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## change in physical state\n",
    "State= pd.read_csv(os.path.join(data_folder, 'Experiment2_FOA_DisplayState.csv'), sep=';')\n",
    "State['TargetCount']=State.Target1+State.Target2+State.Target3\n",
    "State['Trial']= int(0)\n",
    "State['ChangeMagnitude']= int(0)\n",
    "for current_ID in State.ID.unique():\n",
    "    for current_block in State[State.ID==current_ID].Block.unique():\n",
    "        block_trials= State[(State.ID==current_ID) & (State.Block==current_block)].index\n",
    "        for iTrial, iRow in enumerate(block_trials):\n",
    "            State.set_value(iRow, 'Trial', iTrial)\n",
    "            if iTrial>0:\n",
    "                State.set_value(iRow, 'ChangeMagnitude', State.TargetCount[iRow]-State.TargetCount[iRow-1])     \n",
    "                \n",
    "# splitting signed change magnitude into event type (appearance vs. disappearance) and absolute change magnitude\n",
    "State['EventType']= 'appearance'\n",
    "State.set_value(State[State.ChangeMagnitude<0].index, 'EventType', 'disappearance')\n",
    "State['ChangeMagnitude']= State['ChangeMagnitude'].abs()\n",
    "\n",
    "### Loadng responses\n",
    "Response= pd.read_csv(os.path.join(data_folder, 'Experiment2_FOA_Response.csv'), sep=';')\n",
    "\n",
    "### computing response time delay and response time difference for each State Change\n",
    "State['FirstResponse']= np.nan\n",
    "State['LastResponse']= np.nan\n",
    "State['ResponseCount']= int(0)\n",
    "for iRow in range(len(State)):\n",
    "    # skipping the first trial, since this the display onset rather than a change\n",
    "    if np.isnan(State.ChangeMagnitude[iRow]):\n",
    "        continue\n",
    "        \n",
    "    # identifying response time window between state changes\n",
    "    response_start= State.ChangeTime[iRow]\n",
    "    if iRow==len(State)-1: # last trial of the last block\n",
    "        response_end= State.Duration[iRow]\n",
    "    elif State.Block[iRow+1]!=State.Block[iRow]: # last trial of the block\n",
    "        response_end= State.Duration[iRow]\n",
    "    else: # normal trial\n",
    "        response_end= State.ChangeTime[iRow+1]\n",
    "        \n",
    "    # identifying reponses\n",
    "    iResponse= Response[(Response.ID==State.ID[iRow]) & (Response.Block==State.Block[iRow]) & (Response.Time>=response_start) & (Response.Time<response_end)].index\n",
    "    State.set_value(iRow, 'ResponseCount', len(iResponse))\n",
    "    if len(iResponse)>0:\n",
    "        State.set_value(iRow, 'FirstResponse', Response.Time[iResponse[0]]-response_start)\n",
    "        State.set_value(iRow, 'LastResponse', Response.Time[iResponse[-1]]-response_start)\n",
    "    else:\n",
    "        State.set_value(iRow, 'FirstResponse', np.nan)\n",
    "        State.set_value(iRow, 'LastResponse', np.nan)\n",
    "\n",
    "# computing time bracket for multikey reponses\n",
    "State['TimeBracket']= State.LastResponse-State.FirstResponse        \n",
    "\n",
    "# identifying valid trials (numbers of presses/releases matches the number of state changes)\n",
    "State['Valid']= State.ChangeMagnitude==State.ResponseCount\n",
    "\n",
    "### computing average response time brackets for two and three event\n",
    "ResponseBrackets= State[(State.Valid) & (State.ChangeMagnitude>1)].groupby(['ID', 'EventType', 'ChangeMagnitude']).apply(\n",
    "    lambda x: pd.Series({'MeanRT': x.TimeBracket.mean(),\n",
    "                         'MinRT': x.TimeBracket.min(),\n",
    "                         'MaxRT': x.TimeBracket.max(),\n",
    "                         'StdRT': x.TimeBracket.std()})).reset_index()\n",
    "ResponseBrackets.to_csv(os.path.join(data_folder, 'Experiment2_FOA_Estimate.csv'), sep=';', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing raw results and computing subjective states and their corresponding duration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done!                      \n"
     ]
    }
   ],
   "source": [
    "### loading raw data and estimate from the physically disappearing displays\n",
    "results= pd.read_csv(os.path.join(data_folder, 'Experiment2_Main.csv'), sep=';')\n",
    "\n",
    "## loading estimates for the finger-onset asynchrony (see \"Experiment 1. Preliminary FOA analysis.ipynb\")\n",
    "FOA= ResponseBrackets\n",
    "\n",
    "## converting event type labels to integer codes\n",
    "FOA['Event']= int(0)\n",
    "FOA= FOA.set_value((FOA.EventType=='appearance'), 'Event', int(1))\n",
    "\n",
    "# marking individual events as belonging to a group of simultaneous events (or not!)\n",
    "results['SimCount']= 0\n",
    "\n",
    "# computing (in)visibility duration\n",
    "subjective_state_change= pd.DataFrame(columns= ['ID', 'Block', 'BlockDuration', 'Aligned', \n",
    "                                                'MasksN',  'Trial', 'TargetCount', 'Time', 'Duration'])\n",
    "\n",
    "for current_observer in results.ID.unique():\n",
    "    for current_block in range(5, 9):\n",
    "        # verbose\n",
    "        print('\\rObserver %s, block %d'%(current_observer, current_block), end=' ')\n",
    "        \n",
    "        # picking block trials\n",
    "        iBlockTrials= results[(results.ID==current_observer) & (results.Block==current_block)].index\n",
    "        \n",
    "        ## ---------- Simultaneity ----------\n",
    "        for iTrial, iRow in enumerate(iBlockTrials):\n",
    "            ## checking if this is still is an unassigned event\n",
    "            if results.SimCount[iRow]!= 0:\n",
    "                continue\n",
    "            \n",
    "            ## figuring out how many consecutive events of the same type can we have\n",
    "            event_time= []\n",
    "            for iConsecutiveEvent in range(3):\n",
    "                if (iConsecutiveEvent+iTrial>=len(iBlockTrials)) or (results.Event[iRow]!=results.Event[iRow+iConsecutiveEvent]):\n",
    "                    break\n",
    "                event_time.append(results.Time[iRow+iConsecutiveEvent])\n",
    "            \n",
    "            ## trying for three\n",
    "            if len(event_time)==3:\n",
    "                dT= event_time[2]-event_time[0]\n",
    "                iBracket= FOA[(FOA.ID==current_observer) & (FOA.Event==results.Event[iRow]) & (FOA.ChangeMagnitude==3)].index\n",
    "                if len(iBracket)>0 and dT>=FOA.MinRT[iBracket].values[0] and dT<=FOA.MaxRT[iBracket].values[0]:\n",
    "                    # Match! Fill out and skip the rest of the loop\n",
    "                    for iConsecutiveEvent in range(3):\n",
    "                        results.set_value(iRow+iConsecutiveEvent, 'SimCount', 3)\n",
    "                    continue\n",
    "                    \n",
    "            ## trying for twos\n",
    "            if len(event_time)>=2:\n",
    "                dT= event_time[1]-event_time[0]\n",
    "                iBracket= FOA[(FOA.ID==current_observer) & (FOA.Event==results.Event[iRow]) & (FOA.ChangeMagnitude==2)].index\n",
    "                if len(iBracket)>0 and dT>=FOA.MinRT[iBracket].values[0] and dT<=FOA.MaxRT[iBracket].values[0]:\n",
    "                    # Match! Fill out and skip the rest of the loop\n",
    "                    for iConsecutiveEvent in range(2):\n",
    "                        results.set_value(iRow+iConsecutiveEvent, 'SimCount', 2)\n",
    "                    continue\n",
    "            \n",
    "            ## single event, oh, well...\n",
    "            results.set_value(iRow, 'SimCount', 1)\n",
    "            \n",
    "        ## (in)visibility duration\n",
    "        # block constants\n",
    "        current_entry= {'ID': current_observer, \n",
    "                        'Block': current_block, \n",
    "                        'BlockDuration': results.Duration[iBlockTrials[0]],  \n",
    "                        'Aligned': results.Aligned[iBlockTrials[0]], \n",
    "                        'MasksN': results.MasksN[iBlockTrials[0]]}\n",
    "        \n",
    "        # adding an onset state - all visibile\n",
    "        current_entry['Trial']= 0\n",
    "        current_entry['TargetCount']= 3\n",
    "        current_entry['Duration']= 0\n",
    "        current_entry['Time']= 0\n",
    "        subjective_state_change.loc[subjective_state_change.shape[0]] = pd.Series(current_entry)\n",
    "        \n",
    "        CurrentTargetCount= 3\n",
    "        PrevioiusEventTime= 0\n",
    "        # going through events\n",
    "        for iTrial, iRow in enumerate(iBlockTrials):\n",
    "            current_entry['Trial']= iTrial+1\n",
    "            if results.Event[iRow]==0:\n",
    "                CurrentTargetCount-= 1\n",
    "            else:\n",
    "                CurrentTargetCount+= 1\n",
    "            current_entry['TargetCount']= CurrentTargetCount\n",
    "            current_entry['Time']=  results.Time[iRow]/1000.0\n",
    "            subjective_state_change.set_value(len(subjective_state_change)-1, \n",
    "                                              'Duration', \n",
    "                                              results.Time[iRow]/1000.0-PrevioiusEventTime)\n",
    "            if iTrial==len(iBlockTrials)-1: # the last trial\n",
    "                current_entry['Duration']= current_entry['BlockDuration']-results.Time[iRow]/1000.0\n",
    "            PrevioiusEventTime= results.Time[iRow]/1000.0\n",
    "            subjective_state_change.loc[subjective_state_change.shape[0]] = pd.Series(current_entry)            \n",
    "            \n",
    "print('\\rDone!                      ')\n",
    "\n",
    "results.to_csv(os.path.join(data_folder, 'Experiment2_Main.csv'), sep=';', index=False)\n",
    "subjective_state_change.to_csv(os.path.join(data_folder, 'Experiment2_DisappearanceDuration.csv'), sep=';', index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}