Progress summer

operantanalysis/.ipynb_checkpoints/Lickometer_analysis_9March-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

operantanalysis/operantanalysis.py

@@ -14,7 +14,7 @@
            "cue_responding_duration", "lever_pressing", "lever_press_latency", "lever_press_latency_PavCA",
            "total_head_pokes",
            "num_successful_go_nogo_trials", "count_go_nogo_trials", "num_switch_trials", "bin_by_time",
-           "lever_press_lat_gng", "RVI_gng_weird", "RVI_nogo_latency", "lever_press_latency_Switch"]
+           "lever_press_lat_gng", "lever_press_lat_gng_new", "RVI_gng_weird", "RVI_nogo_latency", "lever_press_latency_Switch"]
 
 
 def loop_over_days(column_list, behavioral_test_function):
@@ -594,6 +594,71 @@ def lever_press_lat_gng(timecode, eventcode, lever_on, lever_press):
         return round(statistics.mean(press_latency), 3)
     else:
         return 0
+"""
+def lever_press_lat_gng(timecode, eventcode, lever_on, lever_press):
+
+    :param timecode: list of times (in seconds) when events occurred
+    :param eventcode: list of events that happened in a session
+    :param lever_on: event name for lever presentation
+    :param lever_press: event name for lever press
+    :return: the mean latency to press the lever in seconds
+
+    lever_on = get_events_indices(eventcode, [lever_on, 'EndSession'])
+    go_trial = get_events_indices(eventcode, [go_start, 'EndSession'])
+    nogo_trial = get_events_indices(eventcode, [nogo_start, 'EndSession'])
+
+    for i in range(len(lever_on) - 1):
+        for j in range(len(go_trial)-1): #recall len(go_trial) = 30 should be true
+            go_trial_idx = go_trial[j]
+            if lever_press in eventcode[lever_on_idx:lever_on[i + 1]]:
+                lever_press_idx = eventcode[lever_on_idx:lever_on[i + 1]].index(lever_press)
+                press_latency += [round(timecode[lever_on_idx + lever_press_idx] - timecode[lever_on_idx], 2)]
+            else pass
+        for range of nogo trial
+            if lever_press in eventcode[lever_on_idx:lever_on[i + 1]]:
+                calculate press latency nogo
+            else pass
+    if latency > 0, return round press latency to 2 digits
+    else return 0
+#############################################   
+"""
+def lever_press_lat_gng_new(timecode, eventcode, lever_press, nogo_start):
+    """
+    :param timecode: list of times (in seconds) when events occurred
+    :param eventcode: list of events that happened in a session
+    :param lever_press: event name(s) for when lever(s) pressed
+    :param nogo_start: event name beginning of nogo trial (ie led light on)
+    :return: the mean latency to press the lever in seconds
+     """
+    lever_on = get_events_indices(eventcode, ['LLeverOn', 'RLeverOn', 'EndSession'])
+    press_latency_go = []
+    press_latency_nogo = []
+
+    for i in range(len(lever_on) - 1):
+        lever_on_idx = lever_on[i]
+        if nogo_start in eventcode[lever_on_idx:lever_on[i + 1]]: # this nesting order OK since MEDPC has light-on AFTER lever-on
+            # print("Light on")
+            if lever_press in eventcode[lever_on_idx:lever_on[i + 1]]:
+                lever_press_idx = eventcode[lever_on_idx:lever_on[i + 1]].index(lever_press)
+                press_latency_nogo += [round(timecode[lever_on_idx + lever_press_idx] - timecode[lever_on_idx], 2)]
+            else: pass # this means nogo trial without lever press
+        else: # if lever on but light isnt, then go trial
+            # print("no light")
+            if lever_press in eventcode[lever_on_idx:lever_on[i + 1]]:
+                lever_press_idx = eventcode[lever_on_idx:lever_on[i + 1]].index(lever_press)
+                press_latency_go += [round(timecode[lever_on_idx + lever_press_idx] - timecode[lever_on_idx], 2)]
+            else: pass # this means go trial without lever press
+
+    if len(press_latency_go) > 0:
+        press_latency_go = round(statistics.mean(press_latency_go), 3)
+    else: press_latency_go = 0
+    if len(press_latency_nogo) >0:
+        press_latency_nogo = round(statistics.mean(press_latency_nogo), 3)
+    else: press_latency_nogo = 0
+
+    return press_latency_nogo, press_latency_go
+
+
 
 
 def RVI_gng_weird(timecode, eventcode, lever_on, lever_press):

operantanalysis/scripts/CRF_individual_plotting.py

@@ -29,6 +29,7 @@ def crf_function(loaded_file, i):
 
 (days, df) = loop_over_days(column_list, crf_function)
 print(df.to_string())
+df.to_excel("output.xlsx")
 
 group_means = df.groupby(['Day', 'Subject'])['Dippers', 'Total Presses'].mean().unstack()
 group_sems = df.groupby(['Day', 'Subject'])['Dippers', 'Total Presses'].sem().unstack()

operantanalysis/scripts/Go_NoGo_P1.py

@@ -3,7 +3,7 @@
 import pandas as pd
 
 
-column_list = ['Subject', 'tts', 'Day', 'Dippers', 'Go Trials', 'Successful Go Trials']
+column_list = ['Subject', 'Day', 'Dippers', 'Go Trials', 'Successful Go Trials']
 
 
 def Go_NoGo(loaded_file, i):
@@ -16,7 +16,7 @@ def Go_NoGo(loaded_file, i):
     (dippers, dippers_retrieved, retrieval_latency) = reward_retrieval(timecode, eventcode)
     (go_trials, nogo_trials) = count_go_nogo_trials(eventcode)
     (successful_go_trials, successful_nogo_trials) = num_successful_go_nogo_trials(eventcode)
-    df2 = pd.DataFrame([[loaded_file['Subject'], loaded_file['tts'], int(i + 1), float(dippers), float(go_trials),
+    df2 = pd.DataFrame([[loaded_file['Subject'], int(i + 1), float(dippers), float(go_trials),
                          float(successful_go_trials)]],
                        columns=column_list)
 
@@ -27,8 +27,8 @@ def Go_NoGo(loaded_file, i):
 print(df.to_string())
 df.to_excel("output.xlsx")
 
-group_means = df.groupby(['Day', 'tts'])['Dippers', 'Successful Go Trials'].mean()
-group_sems = df.groupby(['Day', 'tts'])['Dippers', 'Successful Go Trials'].sem()
+group_means = df.groupby(['Day'])['Dippers', 'Successful Go Trials'].mean()
+group_sems = df.groupby(['Day'])['Dippers', 'Successful Go Trials'].sem()
 
-print(df.groupby(['Day', 'tts'])['Dippers', 'Successful Go Trials'].mean().unstack().to_string())
-print(df.groupby(['Day', 'tts'])['Dippers', 'Successful Go Trials'].sem().unstack().to_string())
+print(df.groupby(['Day'])['Dippers', 'Successful Go Trials'].mean().unstack().to_string())
+print(df.groupby(['Day'])['Dippers', 'Successful Go Trials'].sem().unstack().to_string())

operantanalysis/scripts/Go_NoGo_P2.py

@@ -1,12 +1,14 @@
-from operantanalysis import loop_over_days, extract_info_from_file, reward_retrieval,\
-    count_go_nogo_trials, num_successful_go_nogo_trials
+from operantanalysis import loop_over_days, extract_info_from_file, reward_retrieval, \
+    count_go_nogo_trials, num_successful_go_nogo_trials, lever_press_lat_gng_new
+
 import pandas as pd
 import matplotlib
+
 matplotlib.use("TkAgg")
 from matplotlib import pyplot as plt  # noqa
 
-
-column_list = ['Subject', 'tts', 'Day', 'Dippers', 'Hit Rate', 'False Alarm Rate', 'Impulsivity Index']
+column_list = ['Subject', 'Day', 'Dippers', 'Successful Go Trials', 'Successful NoGo Trials', 'Hit Rate',
+               'False Alarm Rate', 'Lever Press Latency Go', 'Lever Press Latency NoGo', 'Impulsivity Index']
 
 
 def Go_NoGo(loaded_file, i):
@@ -19,9 +21,17 @@ def Go_NoGo(loaded_file, i):
     (dippers, dippers_retrieved, retrieval_latency) = reward_retrieval(timecode, eventcode)
     (go_trials, nogo_trials) = count_go_nogo_trials(eventcode)
     (successful_go_trials, successful_nogo_trials) = num_successful_go_nogo_trials(eventcode)
-    df2 = pd.DataFrame([[loaded_file['Subject'], loaded_file['tts'], int(i + 1), float(dippers),
+    lr_press = ['LPressOn', 'RPressOn']
+    light_on = 'LightOn1'
+    (press_latency_go, press_latency_nogo) = lever_press_lat_gng_new(timecode, eventcode, lr_press, light_on)
+
+    df2 = pd.DataFrame([[loaded_file['Subject'], int(i + 1), float(dippers),
+                         float(successful_go_trials),
+                         float(successful_nogo_trials),
                          float(successful_go_trials) / float(go_trials) * 100,
                          (float(nogo_trials) - float(successful_nogo_trials)) / float(nogo_trials) * 100,
+                         float(press_latency_go),
+                         float(press_latency_nogo),
                          float(successful_go_trials) - float(successful_nogo_trials)]],
                        columns=column_list)
 
@@ -32,22 +42,38 @@ def Go_NoGo(loaded_file, i):
 print(df.to_string())
 df.to_excel("output.xlsx")
 
-group_means = df.groupby(['Day', 'tts'])['Dippers', 'Hit Rate', 'False Alarm Rate', 'Impulsivity Index'].mean().unstack()
-group_sems = df.groupby(['Day', 'tts'])['Dippers', 'Hit Rate', 'False Alarm Rate', 'Impulsivity Index'].sem().unstack()
+group_means = df.groupby(['Day'])[
+    'Dippers', 'Hit Rate', 'False Alarm Rate', 'Lever Press Latency Go', 'Lever Press Latency NoGo', 'Impulsivity Index'].mean().unstack()
+group_sems = df.groupby(['Day'])[
+    'Dippers', 'Hit Rate', 'False Alarm Rate', 'Lever Press Latency Go', 'Lever Press Latency NoGo', 'Impulsivity Index'].sem().unstack()
 
-print(df.groupby(['Day', 'tts'])['Dippers', 'Hit Rate', 'False Alarm Rate', 'Impulsivity Index'].mean().unstack().to_string())
-print(df.groupby(['Day', 'tts'])['Dippers', 'Hit Rate', 'False Alarm Rate', 'Impulsivity Index'].sem().unstack().to_string())
+print(df.groupby(['Day'])[
+          'Dippers', 'Hit Rate', 'False Alarm Rate', 'Lever Press Latency Go', 'Lever Press Latency NoGo', 'Impulsivity Index'].mean().unstack().to_string())
+print(df.groupby(['Day'])[
+          'Dippers', 'Hit Rate', 'False Alarm Rate', 'Lever Press Latency Go', 'Lever Press Latency NoGo', 'Impulsivity Index'].sem().unstack().to_string())
 
 group_means['Hit Rate'].plot(legend=True, yerr=group_sems['Hit Rate'], ylim=[0, 100],
                              xlim=[0, days + 1], xticks=(range(1, days + 1, 1)), marker='o', capsize=3, elinewidth=1)
 plt.ylabel('Hit Rate')
 
 group_means['False Alarm Rate'].plot(legend=True, yerr=group_sems['False Alarm Rate'], ylim=[0, 100],
-                                     xlim=[0, days + 1], xticks=(range(1, days + 1, 1)), marker='o', capsize=3, elinewidth=1)
+                                     xlim=[0, days + 1], xticks=(range(1, days + 1, 1)), marker='o', capsize=3,
+                                     elinewidth=1)
 plt.ylabel('False Alarm Rate')
 
+group_means['Lever Press Latency Go'].plot(legend=True, yerr=group_sems['Lever Press Latency Go'],
+                                           xlim=[0, days + 1], xticks=(range(1, days + 1, 1)), marker='o', capsize=3,
+                                           elinewidth=1)
+plt.ylabel('Lever Press Latency Go')
+
+group_means['Lever Press Latency NoGo'].plot(legend=True, yerr=group_sems['Lever Press Latency NoGo'],
+                                             xlim=[0, days + 1], xticks=(range(1, days + 1, 1)), marker='o', capsize=3,
+                                             elinewidth=1)
+plt.ylabel('Lever Press Latency NoGo')
+
 group_means['Impulsivity Index'].plot(legend=True, yerr=group_sems['Impulsivity Index'],
-                                      xlim=[0, days + 1], xticks=(range(1, days + 1, 1)), marker='o', capsize=3, elinewidth=1)
+                                      xlim=[0, days + 1], xticks=(range(1, days + 1, 1)), marker='o', capsize=3,
+                                      elinewidth=1)
 plt.ylabel('Impulsivity Index')
 
 plt.show()

operantanalysis/scripts/RV-I-Go_NoGo_P1 - Copy.py

@@ -0,0 +1,43 @@
+from operantanalysis import loop_over_days, extract_info_from_file, lever_press_latency
+import pandas as pd
+
+
+column_list = ['Subject', 'Day', 'Small Go Trials', 'Large Go Trials', 'Successful Small Go Trials',
+               'Successful Large Go Trials', 'Small Go Latency', 'Large Go Latency']
+
+
+def RVI_Go_NoGo_P1(loaded_file, i):
+    """
+    :param loaded_file: file output from operant box
+    :param i: number of days analyzing
+    :return: data frame of all analysis extracted from file (one animal)
+    """
+    (timecode, eventcode) = extract_info_from_file(loaded_file, 500)
+    (small_go_trials, large_go_trials, small_go_success, large_go_success) = (eventcode.count('GoTrialBegSmallReward'),
+                                                                              eventcode.count('GoTrialBegLargeReward'),
+                                                                              eventcode.count('GoTrialSuccessSmallReward'),
+                                                                              eventcode.count('GoTrialSuccessLargeReward'))
+    small_go_latency = lever_press_latency(timecode, eventcode, 'GoTrialBegSmallReward', 'GoTrialSuccessSmallReward')
+    large_go_latency = lever_press_latency(timecode, eventcode, 'GoTrialBegLargeReward', 'GoTrialSuccessLargeReward')
+
+    df2 = pd.DataFrame([[loaded_file['Subject'], int(i + 1), float(small_go_trials), float(large_go_trials),
+                         float(small_go_success), float(large_go_success), float(small_go_latency),
+                         float(large_go_latency)]],
+                       columns=column_list)
+
+    return df2
+
+
+(days, df) = loop_over_days(column_list, RVI_Go_NoGo_P1)
+print(df.to_string())
+df.to_excel("output.xlsx")
+
+group_means = df.groupby(['Day'])['Successful Small Go Trials', 'Successful Large Go Trials', 'Small Go Latency',
+                                  'Large Go Latency'].mean()
+group_sems = df.groupby(['Day'])['Successful Small Go Trials', 'Successful Large Go Trials', 'Small Go Latency',
+                                 'Large Go Latency'].sem()
+
+print(df.groupby(['Day'])['Successful Small Go Trials', 'Successful Large Go Trials', 'Small Go Latency',
+                          'Large Go Latency'].mean().unstack().to_string())
+print(df.groupby(['Day'])['Successful Small Go Trials', 'Successful Large Go Trials', 'Small Go Latency',
+                          'Large Go Latency'].sem().unstack().to_string())

operantanalysis/scripts/trough_train.py

@@ -24,6 +24,7 @@ def trough_train_function(loaded_file, i):
 
 (days, df) = loop_over_days(column_list, trough_train_function)
 print(df.to_string())
+df.to_excel("operantdata.xlsx")
 
 group_means = df.groupby(['Day'])['Dippers Retrieved', 'Retrieval Latency'].mean()
 group_sems = df.groupby(['Day'])['Dippers Retrieved', 'Retrieval Latency'].sem()