diff --git a/experiment_data/.ipynb_checkpoints/Fig 2e, Fig S14, Table1-checkpoint.ipynb b/experiment_data/.ipynb_checkpoints/Fig 2e, Fig S14, Table1-checkpoint.ipynb new file mode 100644 index 0000000..02242f5 --- /dev/null +++ b/experiment_data/.ipynb_checkpoints/Fig 2e, Fig S14, Table1-checkpoint.ipynb @@ -0,0 +1,905 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from math import *\n", + "import FlowCal as FC\n", + "from scipy.optimize import curve_fit,least_squares\n", + "#from sklearn.linear_model import LinearRegression\n", + "from scipy import stats\n", + "import seaborn as sns\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "def transf_pos(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym*((x/K)**n)/(1+(x/K)**n)+ym*y0\n", + " return result\n", + "\n", + "def transf_neg(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym/(1+(x/K)**n)+y0*ym\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "def channel_median(facsdata_list,channel,flip_tag=True):\n", + " channel_median=[]\n", + " \n", + " if flip_tag==True:\n", + " for i in np.flip(np.arange(len(facsdata_list))):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " else:\n", + " for i in np.arange(0,len(facsdata_list)):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " return np.array(channel_median)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "OC6_levels_=[100]\n", + "for i in range(0,10):\n", + " OC6_levels_.append(OC6_levels_[-1]/3.0)\n", + "OC6_levels_.append(0)\n", + "OC6_levels=np.flip(np.array(OC6_levels_))\n", + "\n", + "folder_='Fig2e/'" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "\n", + "m40_0607_gated=[]\n", + "for i in range(0,12): \n", + " newname='m40_trial1_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40_0607_gated.append(tmp_gated)\n", + "\n", + "\n", + "m40_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial2_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40_0605_gated.append(tmp_gated)\n", + "\n", + "\n", + "m40C1_0627_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial3_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C1_0627_gated.append(tmp_gated)\n", + " \n", + "\n", + "m40C2_0627_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial4_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C2_0627_gated.append(tmp_gated)\n", + " \n", + " \n", + "m40C3_0627_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial5_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C3_0627_gated.append(tmp_gated)\n", + "\n", + " \n", + "m40C1_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial6_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C1_0528_gated.append(tmp_gated)\n", + " \n", + "\n", + "m40C2_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial7_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C2_0528_gated.append(tmp_gated)\n", + " \n", + " \n", + "m40C1_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial8_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " #tmp=FC.io.FCSData(path_0520+'02-Well-A'+str(i+1)+'.fcs')\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C1_0520_gated.append(tmp_gated)\n", + "\n", + "m40C2_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial9_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C2_0520_gated.append(tmp_gated)\n", + "\n", + "m40C3_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial10_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C3_0520_gated.append(tmp_gated)\n", + "\n", + "m40C4_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_trial11_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40C4_0520_gated.append(tmp_gated)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "\n", + "m7C1_0627_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial1_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C1_0627_gated.append(tmp_gated)\n", + " \n", + "\n", + "m7C2_0627_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial2_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C2_0627_gated.append(tmp_gated)\n", + "\n", + "\n", + "m7C3_0627_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial3_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C3_0627_gated.append(tmp_gated)\n", + "\n", + " \n", + "#---------- \n", + "m7C1_0611_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial4_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C1_0611_gated.append(tmp_gated)\n", + "\n", + "\n", + "m7C2_0611_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial5_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C2_0611_gated.append(tmp_gated)\n", + "\n", + "\n", + "m7C3_0611_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial6_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C3_0611_gated.append(tmp_gated)\n", + " \n", + "#-----------\n", + "m7C1_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial7_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C1_0528_gated.append(tmp_gated)\n", + " \n", + " \n", + "m7C2_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial8_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C2_0528_gated.append(tmp_gated)\n", + "\n", + " \n", + "m7C1_0524_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial9_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C1_0524_gated.append(tmp_gated)\n", + " \n", + " \n", + "m7C2_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7_trial10_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C2_0606_gated.append(tmp_gated)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "#-------------\n", + "\n", + "m15C1_0624_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial1_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C1_0624_gated.append(tmp_gated)\n", + "\n", + "m15C2_0624_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial2_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C2_0624_gated.append(tmp_gated)\n", + "\n", + " \n", + "m15C3_0624_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial3_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C3_0624_gated.append(tmp_gated)\n", + "\n", + "\n", + "#----------\n", + "m15C1_0621_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial4_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C1_0621_gated.append(tmp_gated)\n", + "\n", + " \n", + "m15C2_0621_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial5_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C2_0621_gated.append(tmp_gated)\n", + " \n", + "#-------------\n", + "m15_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial6_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15_0607_gated.append(tmp_gated)\n", + "\n", + "\n", + "#--------------------- \n", + "m15C3_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial7_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C3_0528_gated.append(tmp_gated)\n", + "\n", + "m15C4_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial8_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C4_0528_gated.append(tmp_gated)\n", + "\n", + " \n", + "#-----------------\n", + "m15C1_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial9_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C1_0520_gated.append(tmp_gated)\n", + " \n", + "\n", + "m15C2_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_trial10_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15C2_0520_gated.append(tmp_gated)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "m8_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial1_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "m8C1_0621_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial2_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C1_0621_gated.append(tmp_gated)\n", + "\n", + "\n", + "m8C2_0621_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial3_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C2_0621_gated.append(tmp_gated)\n", + " \n", + "\n", + "m8C1_0611_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial4_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C1_0611_gated.append(tmp_gated)\n", + "\n", + "\n", + "m8C2_0611_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial5_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C2_0611_gated.append(tmp_gated)\n", + "\n", + " \n", + "m8C1_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial6_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C1_0528_gated.append(tmp_gated)\n", + " \n", + " \n", + "m8C2_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial7_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C2_0528_gated.append(tmp_gated)\n", + "\n", + " \n", + "m8C1_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial8_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C1_0520_gated.append(tmp_gated)\n", + "\n", + "#--------------- \n", + "m8C1_0524_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_trial9_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8C1_0524_gated.append(tmp_gated)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "\n", + "nwC1_0619_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial1_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0619_gated.append(tmp_gated)\n", + "\n", + "nwC2_0619_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial2_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC2_0619_gated.append(tmp_gated)\n", + "\n", + " \n", + "nwC3_0619_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial3_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC3_0619_gated.append(tmp_gated)\n", + "\n", + "\n", + "\n", + "nwC1_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial4_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0606_gated.append(tmp_gated)\n", + "\n", + "\n", + "#----\n", + "nwC1_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial5_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "nwC2_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial6_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC2_0605_gated.append(tmp_gated)\n", + "\n", + "\n", + "#-------\n", + "nwC1_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial7_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0528_gated.append(tmp_gated)\n", + " \n", + " \n", + "nwC2_0528_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial8_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC2_0528_gated.append(tmp_gated)\n", + " \n", + " \n", + "nwC1_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial9_conc'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0520_gated.append(tmp_gated)\n", + " \n", + " \n", + "nwC3_0520_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial10_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC3_0520_gated.append(tmp_gated)\n", + " \n", + "#--------------------\n", + "nwC1_0524_gated=[]\n", + "for i in range(0,12):\n", + " newname='nw_trial11_conc'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0524_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "median_m7=(channel_median(m7C1_0627_gated,'FL8-A'),\\\n", + " channel_median(m7C2_0627_gated,'FL8-A'),\\\n", + " channel_median(m7C3_0627_gated,'FL8-A'),\\\n", + " channel_median(m7C1_0611_gated,'FL8-A'),\\\n", + " channel_median(m7C2_0611_gated,'FL8-A'),\\\n", + " channel_median(m7C3_0611_gated,'FL8-A'),\\\n", + " channel_median(m7C1_0528_gated,'FL8-A'),\\\n", + " channel_median(m7C2_0528_gated,'FL8-A'),\\\n", + " channel_median(m7C1_0524_gated,'FL8-A'),\\\n", + " channel_median(m7C2_0606_gated,'FL8-A')\n", + " )\n", + "\n", + "median_m40=(channel_median(m40C1_0627_gated,'FL8-A'),\\\n", + " channel_median(m40C2_0627_gated,'FL8-A'),\\\n", + " channel_median(m40C3_0627_gated,'FL8-A'),\\\n", + " channel_median(m40C1_0528_gated,'FL8-A'),\\\n", + " channel_median(m40C2_0528_gated,'FL8-A'),\\\n", + " channel_median(m40C1_0520_gated,'FL8-A'),\\\n", + " channel_median(m40C2_0520_gated,'FL8-A'),\\\n", + " channel_median(m40C3_0520_gated,'FL8-A'),\\\n", + " channel_median(m40C4_0520_gated,'FL8-A'),\\\n", + " channel_median(m40_0607_gated,'FL8-A'),\\\n", + " channel_median(m40_0605_gated,'FL8-A')\n", + " )\n", + "\n", + "\n", + "median_nw=(channel_median(nwC1_0619_gated,'FL8-A'),\\\n", + " channel_median(nwC2_0619_gated,'FL8-A'),\\\n", + " channel_median(nwC3_0619_gated,'FL8-A'),\\\n", + " channel_median(nwC1_0528_gated,'FL8-A'),\\\n", + " channel_median(nwC2_0528_gated,'FL8-A'),\\\n", + " channel_median(nwC1_0524_gated,'FL8-A'),\\\n", + " channel_median(nwC1_0520_gated,'FL8-A'),\\\n", + " channel_median(nwC3_0520_gated,'FL8-A'),\\\n", + " channel_median(nwC1_0606_gated,'FL8-A'),\\\n", + " channel_median(nwC1_0605_gated,'FL8-A'),\\\n", + " channel_median(nwC2_0605_gated,'FL8-A') \n", + " )\n", + "\n", + "median_m15=(channel_median(m15C1_0624_gated,'FL8-A'),\\\n", + " channel_median(m15C2_0624_gated,'FL8-A'),\\\n", + " channel_median(m15C3_0624_gated,'FL8-A'),\\\n", + " channel_median(m15C1_0621_gated,'FL8-A'),\\\n", + " channel_median(m15C2_0621_gated,'FL8-A'),\\\n", + " channel_median(m15C3_0528_gated,'FL8-A'),\\\n", + " channel_median(m15C4_0528_gated,'FL8-A'),\\\n", + " channel_median(m15C1_0520_gated,'FL8-A'),\\\n", + " channel_median(m15C2_0520_gated,'FL8-A'),\\\n", + " channel_median(m15_0607_gated,'FL8-A')\n", + " )\n", + "\n", + "median_m8=(channel_median(m8C1_0621_gated,'FL8-A'),\\\n", + " channel_median(m8C2_0621_gated,'FL8-A'),\\\n", + " channel_median(m8C1_0611_gated,'FL8-A'),\\\n", + " channel_median(m8C2_0611_gated,'FL8-A'),\\\n", + " channel_median(m8C1_0528_gated,'FL8-A'),\\\n", + " channel_median(m8C2_0528_gated,'FL8-A'),\\\n", + " channel_median(m8C1_0520_gated,'FL8-A'),\\\n", + " channel_median(m8C1_0524_gated,'FL8-A'),\\\n", + " channel_median(m8_0605_gated,'FL8-A')\n", + " )\n", + "#------\n", + "mean_m7=np.mean(median_m7,axis=0)\n", + "std_m7=np.std(median_m7,axis=0)\n", + "stder_m7=stats.sem(median_m7,axis=0)\n", + "\n", + "mean_m40=np.mean(median_m40,axis=0)\n", + "std_m40=np.std(median_m40,axis=0)\n", + "stder_m40=stats.sem(median_m40,axis=0)\n", + "\n", + "mean_nw=np.mean(median_nw,axis=0)\n", + "std_nw=np.std(median_nw,axis=0)\n", + "stder_nw=stats.sem(median_nw,axis=0)\n", + "\n", + "mean_m15=np.mean(median_m15,axis=0)\n", + "std_m15=np.std(median_m15,axis=0)\n", + "stder_m15=stats.sem(median_m15,axis=0)\n", + "\n", + "mean_m8=np.mean(median_m8,axis=0)\n", + "std_m8=np.std(median_m8,axis=0)\n", + "stder_m8=stats.sem(median_m8,axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Fig2e\n", + "fig=plt.figure(figsize=(6,5))\n", + "ax=fig.add_subplot(111)\n", + "ax.set_xscale('log')\n", + "\n", + "ax.errorbar(OC6_levels,mean_m7,yerr=stder_m7,color='orange',fmt='.',label='mut7: plux_TCTC')\n", + "ax.errorbar(OC6_levels,mean_m15,yerr=stder_m15,color='mediumseagreen',fmt='.',label='mut15: plux_TATC')\n", + "ax.errorbar(OC6_levels,mean_m8,yerr=stder_m8,color='brown',fmt='.',label='mut8: plux_TTAA')\n", + "ax.errorbar(OC6_levels,mean_m40,yerr=stder_m40,fmt='.',color='violet',label='mut40: plux_TCCC')\n", + "ax.errorbar(OC6_levels,mean_nw,yerr=stder_nw,color='royalblue',fmt='.',label='plux_rep')\n", + "\n", + "ax.plot(OC6_levels,y_fit_m7,color='orange',ls='--')\n", + "ax.plot(OC6_levels,y_fit_m15,color='mediumseagreen',ls='--')\n", + "ax.plot(OC6_levels,y_fit_m8,color='brown',ls='--')\n", + "ax.plot(OC6_levels,y_fit_m40,color='violet',ls='--')\n", + "ax.plot(OC6_levels,y_fit_nw,color='royalblue',ls='--')\n", + "\n", + "ax.set_xlabel('OC6 level (uM)',fontsize=12.5)\n", + "ax.set_ylabel('mCherry level (a.u.)',fontsize=12.5)\n", + "\n", + "ax.tick_params(direction='in')\n", + "\n", + "ax.legend(loc='upper left',fontsize=13)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "# the following section is for sensitivity analysis as in Fig S14\n", + "\n", + "from SALib.sample import saltelli\n", + "from SALib.analyze import sobol" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def fiterr_(param,y0):\n", + " y_param_=transf_pos(AHL_levels,*param)\n", + " y_err=np.sqrt(np.sum((y_param_-y0)**2))\n", + " \n", + " return y_err\n" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.12255987 0.02476677 0.78292618 0.01262282]\n" + ] + } + ], + "source": [ + "ydata=mean_m7 # can also be mean_m8, mean_m7, mean_m40\n", + "problem={\n", + " 'num_vars':4,\n", + " 'names':['K','y0','ym','n'],\n", + " 'bounds':[[0,100], # 100uM is the maximum OC6 level used in experiment\n", + " [0,ydata[0]/ydata[-1]],\n", + " [ydata[-1],1e5],\n", + " [0.2,1.0]]\n", + " }\n", + "param_values = saltelli.sample(problem, 2000)\n", + "Y=np.zeros([param_values.shape[0]])\n", + "\n", + "for i in range(0,len(param_values)):\n", + " Y[i]=fiterr_(param_values[i],ydata)\n", + "\n", + "# correspondingly, Si_m7, Si_m8, Si_m40\n", + "Si_m7=sobol.analyze(problem,Y)\n", + "print(Si_m7['S1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# FigS14\n", + "fig=plt.figure(figsize=(5,3.5))\n", + "ax=fig.add_subplot(111)\n", + "\n", + "ax.bar(x=np.linspace(0,3,4),height=Si_m7['S1'],width=0.18,color='cornflowerblue',alpha=0.8,label='mut7')\n", + "ax.bar(x=np.linspace(0,3,4)+0.19,height=Si_m8['S1'],width=0.18,color='coral',alpha=0.8,label='mut8')\n", + "ax.bar(x=np.linspace(0,3,4)+0.19*2,height=Si_m15['S1'],width=0.18,color='grey',alpha=0.8,label='mut15')\n", + "ax.bar(x=np.linspace(0,3,4)+0.19*3,height=Si_m40['S1'],width=0.18,color='firebrick',alpha=0.8,label='mut40')\n", + "ax.legend(loc='upper left',fontsize=12)\n", + "\n", + "ax.tick_params(direction='in',labelsize=11)\n", + "\n", + "ax.set_xticks([0.3,1.3,2.3,3.3])\n", + "ax.set_xticklabels(['$K_d$','$\\\\beta_0$','$\\\\beta_m$','n'],size=12.5)\n", + "\n", + "ax.set_ylabel('first order sensitivity',fontsize=12)\n", + "ax.set_xlabel('fitting parameters',fontsize=12)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fitting parameters in Table 1:\n", + "m40: [1.49781084e+01 4.95429948e-03 5.52104223e+03 3.52401086e-01] 272.142479873398\n", + "m7: [5.00000000e+01 9.09719012e-02 1.90556442e+03 4.82165996e-01] 143.13017752983183\n", + "m8: [5.00000000e+01 1.90638562e-01 7.28740934e+02 5.39512333e-01] 47.27119391562186\n", + "m15: [5.00000000e+01 4.44653562e-02 2.67854351e+03 4.25843483e-01] 111.12228274507841\n", + "nw: [2.52169860e-01 3.40848148e-01 7.34592634e+02 6.68966183e-01] 242.1089584412443\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# parameter fitting of transfer functions as Table 1\n", + "\n", + "# beta_0: 0, ydata[0]/ydata[-1]\n", + "# beta_m: ydata[-1], 1e5\n", + "\n", + "print('fitting parameters in Table 1:')\n", + "ydata=mean_m40\n", + "b_range=([0.0,0,ydata[-1],0.2],[0.5e2,ydata[0]/ydata[-1],1e5,1.0])\n", + "\n", + "coef_m40,pcov_m40=curve_fit(transf_pos,OC6_levels,ydata,bounds=b_range)\n", + "y_fit_m40=transf_pos(OC6_levels,*coef_m40)\n", + "r_m40=np.linalg.norm(ydata-y_fit_m40)\n", + "plt.xscale('log')\n", + "print('m40: ',coef_m40,r_m40)\n", + "\n", + "plt.plot(OC6_levels,ydata,c='k')\n", + "plt.plot(OC6_levels,y_fit_m40,c='r',ls='--')\n", + "\n", + "#---------\n", + "ydata=mean_m7\n", + "b_range=([0,0,ydata[-1],0.3],[0.5e2,ydata[0]/ydata[-1],1e5,1.0])\n", + "\n", + "coef_m7,pcov_m7=curve_fit(transf_pos,OC6_levels,ydata,bounds=b_range)\n", + "y_fit_m7=transf_pos(OC6_levels,*coef_m7)\n", + "r_m7=np.linalg.norm(ydata-y_fit_m7)\n", + "print('m7: ',coef_m7,r_m7)\n", + "\n", + "plt.xscale('log')\n", + "plt.plot(OC6_levels,ydata,c='b')\n", + "plt.plot(OC6_levels,y_fit_m7,c='g',ls='--')\n", + "\n", + "#-----\n", + "ydata=mean_m8\n", + "b_range=([0.0,0,ydata[-1],0.3],[0.5e2,ydata[0]/ydata[-1],1e5,1.0])\n", + "\n", + "coef_m8,pcov_m8=curve_fit(transf_pos,OC6_levels,ydata,bounds=b_range)\n", + "y_fit_m8=transf_pos(OC6_levels,*coef_m8)\n", + "r_m8=np.linalg.norm(ydata-y_fit_m8)\n", + "print('m8: ',coef_m8,r_m8)\n", + "\n", + "plt.xscale('log')\n", + "plt.plot(OC6_levels,ydata,c='b')\n", + "plt.plot(OC6_levels,y_fit_m8,c='g',ls='--')\n", + "\n", + "\n", + "#-----\n", + "ydata=mean_m15\n", + "b_range=([0.0,0,ydata[-1],0.3],[0.5e2,ydata[0]/ydata[-1],1e5,1.0])\n", + "\n", + "coef_m15,pcov_m15=curve_fit(transf_pos,OC6_levels,ydata,bounds=b_range)\n", + "y_fit_m15=transf_pos(OC6_levels,*coef_m15)\n", + "r_m15=np.linalg.norm(ydata-y_fit_m15)\n", + "print('m15: ',coef_m15,r_m15)\n", + "\n", + "plt.xscale('log')\n", + "plt.plot(OC6_levels,ydata,c='b')\n", + "plt.plot(OC6_levels,y_fit_m15,c='g',ls='--')\n", + "\n", + "#-----\n", + "bnw_range=([0.0,0,0.1,0.0],[5,mean_nw[-1]/mean_nw[0],1.5e3,1.5])\n", + "\n", + "ydata=mean_nw\n", + "coef_nw,pcov_nw=curve_fit(transf_neg,OC6_levels,ydata,bounds=bnw_range)\n", + "y_fit_nw=transf_neg(OC6_levels,*coef_nw)\n", + "r_nw=np.linalg.norm(ydata-y_fit_nw)\n", + "print('nw: ',coef_nw,r_nw)\n", + "\n", + "plt.xscale('log')\n", + "plt.plot(OC6_levels,ydata,c='b')\n", + "plt.plot(OC6_levels,y_fit_nw,c='g',ls='--')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/experiment_data/.ipynb_checkpoints/Fig 4c-checkpoint.ipynb b/experiment_data/.ipynb_checkpoints/Fig 4c-checkpoint.ipynb new file mode 100644 index 0000000..009b41b --- /dev/null +++ b/experiment_data/.ipynb_checkpoints/Fig 4c-checkpoint.ipynb @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from math import *\n", + "import FlowCal as FC\n", + "from scipy.optimize import curve_fit,least_squares\n", + "#from sklearn.linear_model import LinearRegression\n", + "from scipy import stats\n", + "import seaborn as sns\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def transf_pos(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym*((x/K)**n)/(1+(x/K)**n)+ym*y0\n", + " return result\n", + "\n", + "def transf_neg(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym/(1+(x/K)**n)+y0*ym\n", + " return result\n", + "\n", + "def channel_median(facsdata_list,channel,flip_tag=True):\n", + " channel_median=[]\n", + " \n", + " if flip_tag==True:\n", + " for i in np.flip(np.arange(len(facsdata_list))):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " else:\n", + " for i in np.arange(0,len(facsdata_list)):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " return np.array(channel_median)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "OC6_levels_=[100]\n", + "for i in range(0,10):\n", + " OC6_levels_.append(OC6_levels_[-1]/3.0)\n", + "OC6_levels_.append(0)\n", + "OC6_levels=np.flip(np.array(OC6_levels_))\n", + "\n", + "folder_='Fig4c/'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#06-07\n", + "gatefrac=0.8\n", + "\n", + "m40_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40_0607_gated.append(tmp_gated)\n", + "\n", + "\n", + "m15_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15_0607_gated.append(tmp_gated)\n", + "\n", + "#=============+\n", + "R1_m40_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m40_0607_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m40_0607_gated.append(tmp_gated)\n", + "\n", + "\n", + "R1_m15_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m15_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m15_0607_gated.append(tmp_gated)\n", + "\n", + "#-----------\n", + "R2_m40_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_m40_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_m40_0607_gated.append(tmp_gated)\n", + "\n", + " \n", + "R2_m15_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_m15_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_m15_0607_gated.append(tmp_gated)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "\n", + "nwC1_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='nwC1_0606_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0606_gated.append(tmp_gated)\n", + "\n", + " \n", + "m7C2_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7C2_0606_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C2_0606_gated.append(tmp_gated)\n", + "\n", + "\n", + "#-------\n", + "R1_nwC1_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_nwC1_0606_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_nwC1_0606_gated.append(tmp_gated)\n", + "\n", + "\n", + "R1_m7_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m7_0606_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m7_0606_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#06-05 data\n", + "gatefrac=0.8\n", + "\n", + "nwC1_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='nwC1_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0605_gated.append(tmp_gated)\n", + "\n", + " \n", + "nwC2_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='nwC2_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC2_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "m8_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8_0605_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "R1_nwC2_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_nwC2_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_nwC2_0605_gated.append(tmp_gated)\n", + " \n", + "R1_m8_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m8_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m8_0605_gated.append(tmp_gated)\n", + " \n", + " \n", + "R1_m40_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m40_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m40_0605_gated.append(tmp_gated)\n", + " \n", + " \n", + "#-------\n", + "R2_nwC1_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_nwC1_0605_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_nwC1_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "R2_nwC2_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_nwC2_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_nwC2_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "R2_m8_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_m8_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_m8_0605_gated.append(tmp_gated)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# 06-04\n", + "wt_C1_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='wt_C1_0604_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " wt_C1_0604_gated.append(tmp_gated)\n", + "\n", + "wt_C2_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='wt_C2_0604_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " wt_C2_0604_gated.append(tmp_gated)\n", + "\n", + " \n", + "R_C1_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='R_C1_0604_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R_C1_0604_gated.append(tmp_gated)\n", + "\n", + " \n", + "R_C2_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='R_C2_0604_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R_C2_0604_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "#06-07\n", + "m40_0607_mch=channel_median(m40_0607_gated,'FL8-A')\n", + "m15_0607_mch=channel_median(m15_0607_gated,'FL8-A')\n", + "\n", + "R1_m40_0607_gfp=channel_median(R1_m40_0607_gated,'FL1-A')\n", + "R1_m15_0607_gfp=channel_median(R1_m15_0607_gated,'FL1-A')\n", + "\n", + "R2_m40_0607_gfp=channel_median(R2_m40_0607_gated,'FL1-A')\n", + "R2_m15_0607_gfp=channel_median(R2_m15_0607_gated,'FL1-A')\n", + "\n", + "\n", + "R1_m40_0607_bfp=channel_median(R1_m40_0607_gated,'FL5-A')\n", + "R1_m15_0607_bfp=channel_median(R1_m15_0607_gated,'FL5-A')\n", + "\n", + "R2_m40_0607_bfp=channel_median(R2_m40_0607_gated,'FL5-A')\n", + "R2_m15_0607_bfp=channel_median(R2_m15_0607_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "#06-05\n", + "nwC1_0605_mch=channel_median(nwC1_0605_gated,'FL8-A')\n", + "nwC2_0605_mch=channel_median(nwC2_0605_gated,'FL8-A')\n", + "m8_0605_mch=channel_median(m8_0605_gated,'FL8-A')\n", + "\n", + "R1_nwC2_0605_gfp=channel_median(R1_nwC2_0605_gated,'FL1-A')\n", + "R1_m8_0605_gfp=channel_median(R1_m8_0605_gated,'FL1-A')\n", + "R2_nwC1_0605_gfp=channel_median(R2_nwC1_0605_gated,'FL1-A')\n", + "R2_nwC2_0605_gfp=channel_median(R2_nwC2_0605_gated,'FL1-A')\n", + "R2_m8_0605_gfp=channel_median(R2_m8_0605_gated,'FL1-A')\n", + "R1_nwC2_0605_bfp=channel_median(R1_nwC2_0605_gated,'FL5-A')\n", + "R1_m8_0605_bfp=channel_median(R1_m8_0605_gated,'FL5-A')\n", + "R2_nwC1_0605_bfp=channel_median(R2_nwC1_0605_gated,'FL5-A')\n", + "R2_nwC2_0605_bfp=channel_median(R2_nwC2_0605_gated,'FL5-A')\n", + "R2_m8_0605_bfp=channel_median(R2_m8_0605_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#06-06\n", + "nwC1_0605_mch=channel_median(nwC1_0605_gated,'FL8-A')\n", + "nwC1_0606_mch=channel_median(nwC1_0606_gated,'FL8-A')\n", + "m7C2_0606_mch=channel_median(m7C2_0606_gated,'FL8-A')\n", + "\n", + "R1_nwC1_0606_gfp=channel_median(R1_nwC1_0606_gated,'FL1-A')\n", + "R1_m7_0606_gfp=channel_median(R1_m7_0606_gated,'FL1-A')\n", + "R1_nwC1_0606_bfp=channel_median(R1_nwC1_0606_gated,'FL5-A')\n", + "R1_m7_0606_bfp=channel_median(R1_m7_0606_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# 06-04\n", + "wtC1_0604_mch=channel_median(wt_C1_0604_gated,'FL8-A')\n", + "wtC2_0604_mch=channel_median(wt_C2_0604_gated,'FL8-A')\n", + "RC1_0604_gfp=channel_median(R_C1_0604_gated,'FL1-A')\n", + "RC2_0604_gfp=channel_median(R_C2_0604_gated,'FL1-A')\n", + "RC1_0604_bfp=channel_median(R_C1_0604_gated,'FL5-A')\n", + "RC2_0604_bfp=channel_median(R_C2_0604_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "b_range=([0,0,0,0.0],[1.5e3,0.5,3e4,5.0])\n", + "\n", + "xdata=np.concatenate((m8_0605_mch,\\\n", + " nwC1_0605_mch,nwC2_0605_mch,\\\n", + " m8_0605_mch,\\\n", + " nwC2_0605_mch,\\\n", + " nwC1_0606_mch,\\\n", + " m7C2_0606_mch,\\\n", + " wtC1_0604_mch,wtC2_0604_mch,\\\n", + " m40_0607_mch,\\\n", + " m40_0607_mch,\\\n", + " m15_0607_mch,m15_0607_mch\n", + " ))\n", + "\n", + "ydata=np.concatenate((R2_m8_0605_gfp,\\\n", + " R2_nwC1_0605_gfp,R2_nwC2_0605_gfp,\\\n", + " R1_m8_0605_gfp,\\\n", + " R1_nwC2_0605_gfp,\\\n", + " R1_nwC1_0606_gfp,\\\n", + " R1_m7_0606_gfp,\\\n", + " RC1_0604_gfp,RC2_0604_gfp,\\\n", + " R1_m40_0607_gfp,\\\n", + " R2_m40_0607_gfp,\\\n", + " R1_m15_0607_gfp,R2_m15_0607_gfp\n", + " ))\n", + "\n", + "coef_,pcov_=curve_fit(transf_pos,xdata,ydata,bounds=b_range)\n", + "print('fitting: ',coef_)\n", + "x=np.arange(100,7000,100)\n", + "R_fit=transf_pos(x,*coef_)\n", + "\n", + "#-----------------\n", + "fig=plt.figure(figsize=(6,4.5))\n", + "ax=fig.add_subplot(111)\n", + "marker_size=10\n", + "ax.scatter(xdata,ydata,label='experiment',s=marker_size,color='royalblue')\n", + "ax.plot(x,R_fit,label='fitting',color='orange')\n", + "ax.legend(loc='lower right',fontsize=15)\n", + "\n", + "ax.set_xlabel('mCherry (arb. units)',fontsize=15)\n", + "ax.set_ylabel('EYFP (arb. units)',fontsize=15)\n", + "\n", + "ax.tick_params(direction='in')\n", + "\n", + "#fig_path=''\n", + "#plt.savefig(fig_path+'R_transfcn_mch.png',dpi=400) #Fig4c\n", + "#plt.savefig(fig_path+'R_transfcn_mch.eps',format='eps') #Fig4c" + ] + } + ], + "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.8.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/experiment_data/.ipynb_checkpoints/Fig2b, Fig2d, Fig S24, Fig S25-checkpoint.ipynb b/experiment_data/.ipynb_checkpoints/Fig2b, Fig2d, Fig S24, Fig S25-checkpoint.ipynb new file mode 100644 index 0000000..8dd2727 --- /dev/null +++ b/experiment_data/.ipynb_checkpoints/Fig2b, Fig2d, Fig S24, Fig S25-checkpoint.ipynb @@ -0,0 +1,740 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from math import *\n", + "import FlowCal as FC\n", + "from scipy.optimize import curve_fit\n", + "#from sklearn.linear_model import LinearRegression\n", + "from scipy import stats\n", + "import seaborn as sns\n", + "import warnings\n", + "import os\n", + "from shutil import copyfile\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def transf_pos(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym*((x/K)**n)/(1+(x/K)**n)+ym*y0\n", + " return result\n", + "\n", + "def transf_neg(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym/(1+(x/K)**n)+y0*ym\n", + " return result\n", + "\n", + "def activate(x,K,y0,ym,n):\n", + " result=transf_pos(x.sum(),K,y0,ym,n).sum()\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def channel_median(facsdata_list,channel,flip_tag=True):\n", + " channel_median=[]\n", + " \n", + " if flip_tag==True:\n", + " for i in np.flip(np.arange(len(facsdata_list))):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " else:\n", + " for i in np.arange(0,len(facsdata_list)):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " return np.array(channel_median)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "Fig2b_folder_='Fig2b/'\n", + "Fig2d_folder_='Fig2d/'" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial1_+placo_array_noaTc.fcs')\n", + "XL267C1_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "#-----------\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial1_+placo_array_+aTc.fcs')\n", + "XL267C1_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "#----------\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial2_+placo_array_noaTc.fcs')\n", + "XL267C2_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial2_+placo_array_+aTc.fcs')\n", + "XL267C2_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "#----------\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial3_+placo_array_noaTc.fcs')\n", + "XL267C3_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial3_+placo_array_+aTc.fcs')\n", + "XL267C3_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial1_noplaco_array_noaTc.fcs')\n", + "XL267_LR206_C1_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial2_noplaco_array_noaTc.fcs')\n", + "XL267_LR206_C2_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial3_noplaco_array_noaTc.fcs')\n", + "XL267_LR206_C3_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial4_noplaco_array_noaTc.fcs')\n", + "XL267_LR206_C4_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "#-----\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial1_noplaco_array_+aTc.fcs')\n", + "XL267_LR206_C1_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial2_noplaco_array_+aTc.fcs')\n", + "XL267_LR206_C2_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial3_noplaco_array_+aTc.fcs')\n", + "XL267_LR206_C3_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + "\n", + "tmp=FC.io.FCSData(Fig2b_folder_+'trial4_noplaco_array_+aTc.fcs')\n", + "XL267_LR206_C4_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "tmp=FC.io.FCSData(Fig2b_folder_+'trial1_+placo_array_noaTc.fcs')\n", + "XL267C1_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Fig S31\n", + "# a demonstration for gating\n", + "fig=plt.figure(figsize=(7,3.5))\n", + "ax=fig.add_subplot(121)\n", + "#ax.set_xscale('log')\n", + "#ax.set_yscale('log')\n", + "ax.scatter(tmp[:,'FSC-A'],tmp[:,'SSC-A'],s=1)\n", + "\n", + "ax.tick_params(direction='in')\n", + "ax.tick_params(axis='x',labelsize=12)\n", + "ax.set_xlabel('FSC-A',fontsize=12.5)\n", + "ax.set_ylabel('SSC-A',fontsize=12.5)\n", + "ax.set_title('before gating', fontsize=14)\n", + "#-------------\n", + "\n", + "ax=fig.add_subplot(122)\n", + "ax.scatter(XL267C1_LB_gated[:,'FSC-A'],XL267C1_LB_gated[:,'SSC-A'],s=1)\n", + "ax.tick_params(direction='in')\n", + "ax.tick_params(axis='x',labelsize=12)\n", + "ax.set_xlabel('FSC-A',fontsize=12.5)\n", + "#ax.set_ylabel('SSC-A',fontsize=12.5)\n", + "\n", + "ax.set_title('after gating', fontsize=14)\n", + "\n", + "\n", + "#fig_path='/Users/ximing/Documents/technion_stuff/figures/rev_figures/'\n", + "#file_name='gating_effect.png'\n", + "\n", + "#fig.savefig(fig_path+file_name,dpi=400)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "path_='/Users/ximing/Documents/NN_project/NN_project_revision/github_folder/experiment_data/'\n", + "os.mkdir(path_+Fig2d_folder_)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/ximing/Documents/NN_project/NN_project_revision/github_folder/experiment_data/Fig2b/trial3_+placo_array_+aTc.fcs'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# copy files to organized folder\n", + "data_file=path_0609+'02-Well-A2.fcs'\n", + "newname='trial1_+placo_array_noaTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "data_file=path_0609+'02-Well-A3.fcs'\n", + "newname='trial1_+placo_array_+aTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "#-----------\n", + "data_file=path_0609+'02-Well-B2.fcs'\n", + "newname='trial2_+placo_array_noaTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "data_file=path_0609+'02-Well-B3.fcs'\n", + "newname='trial2_+placo_array_+aTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "#-----------\n", + "data_file=path_0609+'02-Well-C2.fcs'\n", + "newname='trial3_+placo_array_noaTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "data_file=path_0609+'02-Well-C3.fcs'\n", + "newname='trial3_+placo_array_+aTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "\n", + "# copy files to organized folder\n", + "data_file=path_0701+'01-Well-A2_LR206+XL267C1_LB.fcs'\n", + "newname='trial1_noplaco_array_noaTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "data_file=path_0701+'01-Well-A3_LR206+XL267C1_aTc_200ngml.fcs'\n", + "newname='trial1_noplaco_array_+aTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "#-----------\n", + "data_file=path_0701+'01-Well-B2.fcs'\n", + "newname='trial2_noplaco_array_noaTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "data_file=path_0701+'01-Well-B3.fcs'\n", + "newname='trial2_noplaco_array_+aTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "#-----------\n", + "data_file=path_0701+'01-Well-C2.fcs'\n", + "newname='trial3_noplaco_array_noaTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "data_file=path_0701+'01-Well-C3.fcs'\n", + "newname='trial3_noplaco_array_+aTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "\n", + "#-----------\n", + "data_file=path_0701+'01-Well-D2.fcs'\n", + "newname='trial4_noplaco_array_noaTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)\n", + "\n", + "data_file=path_0701+'01-Well-D3.fcs'\n", + "newname='trial4_noplaco_array_+aTc.fcs'\n", + "copyfile(data_file,path_+folder_name+newname)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Fig S24\n", + "fig=plt.figure(figsize=(5.8,4.5))\n", + "ax=fig.add_subplot(111)\n", + "ax.set_xscale('log')\n", + "\n", + "alpha_=0.11\n", + "sns.kdeplot(XL267C1_LB_gated[:,'FL1-A'],color='royalblue',fill=1,alpha=alpha_,label='+$P_{lacO}\\cdot array, -aTc$')\n", + "sns.kdeplot(XL267C2_LB_gated[:,'FL1-A'],color='royalblue',fill=1,alpha=alpha_)\n", + "sns.kdeplot(XL267C3_LB_gated[:,'FL1-A'],color='royalblue',fill=1,alpha=alpha_)\n", + "\n", + "sns.kdeplot(XL267C1_aTc_gated[:,'FL1-A'],color='mediumseagreen',fill=1,alpha=alpha_,label='+$P_{lacO}\\cdot array, +aTc$')\n", + "sns.kdeplot(XL267C2_aTc_gated[:,'FL1-A'],color='mediumseagreen',fill=1,alpha=alpha_)\n", + "sns.kdeplot(XL267C3_aTc_gated[:,'FL1-A'],color='mediumseagreen',fill=1,alpha=alpha_)\n", + "\n", + "\n", + "sns.kdeplot(XL267_LR206_C1_LB_gated[:,'FL1-A'],color='grey',fill=1,alpha=alpha_*2,label='-$P_{lacO}\\cdot array, -aTc$')\n", + "sns.kdeplot(XL267_LR206_C2_LB_gated[:,'FL1-A'],color='grey',fill=1,alpha=alpha_*2)\n", + "sns.kdeplot(XL267_LR206_C3_LB_gated[:,'FL1-A'],color='grey',fill=1,alpha=alpha_*2)\n", + "\n", + "sns.kdeplot(XL267_LR206_C1_aTc_gated[:,'FL1-A'],color='orange',fill=1,alpha=alpha_,label='-$P_{lacO}\\cdot array, +aTc$')\n", + "sns.kdeplot(XL267_LR206_C2_aTc_gated[:,'FL1-A'],color='orange',fill=1,alpha=alpha_)\n", + "sns.kdeplot(XL267_LR206_C3_aTc_gated[:,'FL1-A'],color='orange',fill=1,alpha=alpha_)\n", + "\n", + "ax.legend(loc='upper left',fontsize=10)\n", + "ax.set_xlim([0.3*10**2,0.5*10**6])\n", + "\n", + "ax.set_ylabel('')\n", + "ax.set_xlabel('GFP fluoresence (a.u.)',size=12)\n", + "\n", + "\n", + "ax.tick_params(direction='in')\n", + "ax.tick_params(axis='x',labelsize=12)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "LB_median=[np.median(XL267C1_LB_gated[:,'FL1-A']),\\\n", + " np.median(XL267C2_LB_gated[:,'FL1-A']),\\\n", + " np.median(XL267C3_LB_gated[:,'FL1-A']),\\\n", + " ]\n", + "\n", + "aTc_median=[np.median(XL267C1_aTc_gated[:,'FL1-A']),\\\n", + " np.median(XL267C2_aTc_gated[:,'FL1-A']),\\\n", + " np.median(XL267C3_aTc_gated[:,'FL1-A']),\\\n", + " ]\n", + "XL267C1_=[np.median(XL267C1_LB_gated[:,'FL1-A']),np.median(XL267C1_aTc_gated[:,'FL1-A'])]\n", + "XL267C2_=[np.median(XL267C2_LB_gated[:,'FL1-A']),np.median(XL267C2_aTc_gated[:,'FL1-A'])]\n", + "XL267C3_=[np.median(XL267C3_LB_gated[:,'FL1-A']),np.median(XL267C3_aTc_gated[:,'FL1-A'])]" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "XL267_LR206_LB_median=[np.median(XL267_LR206_C1_LB_gated[:,'FL1-A']),\\\n", + " np.median(XL267_LR206_C2_LB_gated[:,'FL1-A']),\\\n", + " np.median(XL267_LR206_C3_LB_gated[:,'FL1-A']),\\\n", + " np.median(XL267_LR206_C4_LB_gated[:,'FL1-A'])\n", + " ]\n", + "\n", + "XL267_LR206_aTc_median=[np.median(XL267_LR206_C1_aTc_gated[:,'FL1-A']),\\\n", + " np.median(XL267_LR206_C2_aTc_gated[:,'FL1-A']),\\\n", + " np.median(XL267_LR206_C3_aTc_gated[:,'FL1-A']),\\\n", + " np.median(XL267_LR206_C4_aTc_gated[:,'FL1-A'])\n", + " ]\n", + "\n", + "mean_=[np.mean(LB_median),np.mean(aTc_median),\\\n", + " np.mean(XL267_LR206_LB_median),np.mean(XL267_LR206_aTc_median)]\n", + "sem_=[stats.sem(LB_median),stats.sem(aTc_median),\\\n", + " stats.sem(XL267_LR206_LB_median),stats.sem(XL267_LR206_aTc_median)]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Fig2b\n", + "fig=plt.figure(figsize=(4,4))\n", + "ax=fig.add_subplot(111)\n", + "\n", + "ax.bar(x=['- aTc\\n','+ aTc\\n'],height=mean_[0:2],yerr=sem_[0:2],color='mediumseagreen',width=0.5,label='with $P_{lacO}\\cdot array$')\n", + "ax.bar(x=['- aTc','+ aTc'],height=mean_[2:],yerr=sem_[2:],color='orange',width=0.5,label='without $P_{lacO}\\cdot array$')\n", + "\n", + "ax.set_title('median GFP levels',fontsize=13)\n", + "ax.tick_params(direction='in')\n", + "ax.tick_params(axis='x',labelsize=13)\n", + "ax.legend(loc='upper right',fontsize=12.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# 0614 data\n", + "gatefrac=0.8\n", + "indx=list(np.arange(2,12))\n", + "\n", + "pAJM1642_C1_gated=[]\n", + "for i in indx:\n", + " newname='R_PF_trial1_conc'+str(i-2)+'.fcs'\n", + " tmp=FC.io.FCSData(Fig2d_folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " pAJM1642_C1_gated.append(tmp_gated)\n", + "\n", + "\n", + "pAJM1642_C2_gated=[]\n", + "for i in indx:\n", + " newname='R_PF_trial2_conc'+str(i-2)+'.fcs'\n", + " tmp=FC.io.FCSData(Fig2d_folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " pAJM1642_C2_gated.append(tmp_gated)\n", + "\n", + " \n", + "pAJM1642_C3_gated=[]\n", + "for i in indx:\n", + " newname='R_PF_trial3_conc'+str(i-2)+'.fcs'\n", + " tmp=FC.io.FCSData(Fig2d_folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " pAJM1642_C3_gated.append(tmp_gated)\n", + "\n", + "#----------------\n", + "\n", + "R_C1_gated=[]\n", + "for i in indx:\n", + " newname='R_OL_trial1_conc'+str(i-2)+'.fcs'\n", + " tmp=FC.io.FCSData(Fig2d_folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R_C1_gated.append(tmp_gated)\n", + "\n", + "\n", + "R_C3_gated=[]\n", + "for i in indx:\n", + " newname='R_OL_trial2_conc'+str(i-2)+'.fcs'\n", + " tmp=FC.io.FCSData(Fig2d_folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R_C3_gated.append(tmp_gated)\n", + " \n", + "\n", + "R_C2_gated=[]\n", + "for i in indx:\n", + " newname='R_OL_trial3_conc'+str(i-2)+'.fcs'\n", + " tmp=FC.io.FCSData(Fig2d_folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R_C2_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'open loop')" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Fig S25\n", + "\n", + "fig=plt.figure(figsize=(6,4.5))\n", + "alpha_=0.2\n", + "\n", + "#-----------\n", + "ax=fig.add_subplot(211)\n", + "ax.set_xscale('log')\n", + "\n", + "sns.kdeplot(R_C1_gated[0][:,'FL1-A'],color=[0.0,0.0,1.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[1][:,'FL1-A'],color=[0.2,0.2,0.8],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[3][:,'FL1-A'],color=[0.3,0.3,0.7],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[4][:,'FL1-A'],color=[0.6,0.6,0.3],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[5][:,'FL1-A'],color=[0.8,0.8,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[6][:,'FL1-A'],color=[0.6,0.8,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[7][:,'FL1-A'],color=[0.4,0.8,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[8][:,'FL1-A'],color=[0.2,0.6,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(R_C1_gated[9][:,'FL1-A'],color=[0.0,0.5,0.0],fill=1,alpha=alpha_)\n", + "\n", + "ax.set_xlim([10**1,0.5*10**6])\n", + "ax.set_ylabel('')\n", + "ax.set_xticklabels('[]')\n", + "ax.tick_params(direction='in')\n", + "ax.set_title('positive feedback',fontsize=14)\n", + "#========================\n", + "ax=fig.add_subplot(212)\n", + "ax.set_xscale('log')\n", + "\n", + "sns.kdeplot(pAJM1642_C1_gated[0][:,'FL1-A'],color=[0.0,0.0,1.0],fill=1,alpha=alpha_,label='OHC14 100 $\\mu$M')\n", + "sns.kdeplot(pAJM1642_C1_gated[1][:,'FL1-A'],color=[0.2,0.2,0.8],fill=1,alpha=alpha_)\n", + "sns.kdeplot(pAJM1642_C1_gated[3][:,'FL1-A'],color=[0.3,0.3,0.7],fill=1,alpha=alpha_)\n", + "sns.kdeplot(pAJM1642_C1_gated[4][:,'FL1-A'],color=[0.6,0.6,0.3],fill=1,alpha=alpha_)\n", + "sns.kdeplot(pAJM1642_C1_gated[5][:,'FL1-A'],color=[0.8,0.8,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(pAJM1642_C1_gated[6][:,'FL1-A'],color=[0.6,0.5,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(pAJM1642_C1_gated[7][:,'FL1-A'],color=[0.4,0.5,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(pAJM1642_C1_gated[8][:,'FL1-A'],color=[0.2,0.5,0.0],fill=1,alpha=alpha_)\n", + "sns.kdeplot(pAJM1642_C1_gated[9][:,'FL1-A'],color=[0.0,0.5,0.0],fill=1,alpha=alpha_,label='OHC14 0.005 $\\mu$M')\n", + "ax.legend(loc='upper left',fontsize=12)\n", + "\n", + "ax.set_xlim([10**1,0.5*10**6])\n", + "ax.set_ylabel('')\n", + "ax.set_xlabel('EYFP level (a.u.)',fontsize=13)\n", + "ax.tick_params(direction='in')\n", + "ax.set_title('open loop',fontsize=14)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([5.08052634e-03, 1.52415790e-02, 4.57247371e-02, 1.37174211e-01,\n", + " 4.11522634e-01, 1.23456790e+00, 3.70370370e+00, 1.11111111e+01,\n", + " 3.33333333e+01, 1.00000000e+02])" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "OHC14_levels_=[100.0]\n", + "for i in range(0,9):\n", + " OHC14_levels_.append(OHC14_levels_[-1]/3.0)\n", + "OHC14_levels=np.flip(np.array(OHC14_levels_))\n", + "OHC14_levels" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "median_R=(channel_median(R_C1_gated,'FL1-A'),\\\n", + " channel_median(R_C2_gated,'FL1-A'),\\\n", + " channel_median(R_C3_gated,'FL1-A'),\\\n", + " )\n", + "mean_R=np.mean(median_R,axis=0)\n", + "std_R=np.std(median_R,axis=0)\n", + "sem_R=stats.sem(median_R)\n", + "#----\n", + "median_pAJM=(channel_median(pAJM1642_C1_gated,'FL1-A'),\\\n", + " channel_median(pAJM1642_C2_gated,'FL1-A'),\\\n", + " channel_median(pAJM1642_C3_gated,'FL1-A'),\\\n", + " )\n", + "mean_pAJM=np.mean(median_pAJM,axis=0)\n", + "std_pAJM=np.std(median_pAJM,axis=0)\n", + "sem_pAJM=stats.sem(median_pAJM)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting parameters for receiver transfer function:\n", + "R_PF: [2.83223032e-01 3.95317073e-02 2.25347249e+04 1.97011244e+00]\n", + "R_OL: [3.40821290e+00 7.23205470e-03 2.56647450e+04 8.09523537e-01]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#fitting, Table 1, column1-2\n", + "b_range=([0,0,0,0.0],[1.5e3,0.5,3e4,5.0])\n", + "\n", + "ydata=mean_R\n", + "coef_R,_=curve_fit(transf_pos,OHC14_levels,ydata,bounds=b_range)\n", + "ym=coef_R\n", + "y_fit_R=transf_pos(OHC14_levels,ym[0],ym[1],ym[2],ym[3])\n", + "\n", + "\n", + "plt.plot(np.log10(OHC14_levels),y_fit_R,color='b')\n", + "plt.plot(np.log10(OHC14_levels),ydata,color='g')\n", + "\n", + "#-------\n", + "ydata=mean_pAJM\n", + "coef_pAJM,_=curve_fit(transf_pos,OHC14_levels,ydata,bounds=b_range)\n", + "ym=coef_pAJM\n", + "y_fit_pAJM=transf_pos(OHC14_levels,ym[0],ym[1],ym[2],ym[3])\n", + "\n", + "\n", + "plt.plot(np.log10(OHC14_levels),y_fit_pAJM,color='violet')\n", + "plt.plot(np.log10(OHC14_levels),ydata,color='r')\n", + "\n", + "print('Fitting parameters for receiver transfer function:')\n", + "print('R_PF: ',coef_R)\n", + "print('R_OL: ',coef_pAJM)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Fig2d \n", + "\n", + "fig=plt.figure(figsize=(5.8,4.5))\n", + "ax=fig.add_subplot(111)\n", + "ax.set_xscale('log')\n", + "\n", + "ax.errorbar(OHC14_levels,mean_pAJM,yerr=sem_pAJM,fmt='.',color='royalblue',label='open loop')\n", + "ax.errorbar(OHC14_levels,mean_R,yerr=sem_R,c='g',fmt='.',label='positive feedback')\n", + "\n", + "ax.plot(OHC14_levels,y_fit_pAJM,c='royalblue',ls='--',label='OL_fitting')\n", + "ax.plot(OHC14_levels,y_fit_R,c='g',ls='--',label='PF_fitting')\n", + "\n", + "#---------------\n", + "ax.set_ylabel('EYFP level (a.u)',fontsize=12.5)\n", + "ax.set_xlabel('OHC14 level (uM)',fontsize=12.5)\n", + "\n", + "ax.tick_params(direction='in')\n", + "ax.set_xscale('log')\n", + "\n", + "ax.legend(loc='upper left',fontsize=13)" + ] + } + ], + "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.8.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/experiment_data/3x3_patterns.ipynb b/experiment_data/3x3_patterns.ipynb index f2d56b1..3cef45c 100644 --- a/experiment_data/3x3_patterns.ipynb +++ b/experiment_data/3x3_patterns.ipynb @@ -243,7 +243,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/experiment_data/4-bit_patterns.ipynb b/experiment_data/4-bit_patterns.ipynb index e9a9ae7..ad476ec 100644 --- a/experiment_data/4-bit_patterns.ipynb +++ b/experiment_data/4-bit_patterns.ipynb @@ -228,7 +228,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/experiment_data/Fig 2e, Fig S14, Table1.ipynb b/experiment_data/Fig 2e, Fig S14, Table1.ipynb index 02c94e5..02242f5 100644 --- a/experiment_data/Fig 2e, Fig S14, Table1.ipynb +++ b/experiment_data/Fig 2e, Fig S14, Table1.ipynb @@ -897,7 +897,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.8.9" } }, "nbformat": 4, diff --git a/experiment_data/Fig 4c.ipynb b/experiment_data/Fig 4c.ipynb new file mode 100644 index 0000000..a417f94 --- /dev/null +++ b/experiment_data/Fig 4c.ipynb @@ -0,0 +1,474 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from math import *\n", + "import FlowCal as FC\n", + "from scipy.optimize import curve_fit,least_squares\n", + "#from sklearn.linear_model import LinearRegression\n", + "from scipy import stats\n", + "import seaborn as sns\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def transf_pos(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym*((x/K)**n)/(1+(x/K)**n)+ym*y0\n", + " return result\n", + "\n", + "def transf_neg(x,K=2.0,y0=0.001,ym=1.5,n=2):\n", + " result=ym/(1+(x/K)**n)+y0*ym\n", + " return result\n", + "\n", + "def channel_median(facsdata_list,channel,flip_tag=True):\n", + " channel_median=[]\n", + " \n", + " if flip_tag==True:\n", + " for i in np.flip(np.arange(len(facsdata_list))):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " else:\n", + " for i in np.arange(0,len(facsdata_list)):\n", + " channel_median.append(np.median(facsdata_list[i][:,channel]))\n", + " \n", + " return np.array(channel_median)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "OC6_levels_=[100]\n", + "for i in range(0,10):\n", + " OC6_levels_.append(OC6_levels_[-1]/3.0)\n", + "OC6_levels_.append(0)\n", + "OC6_levels=np.flip(np.array(OC6_levels_))\n", + "\n", + "folder_='Fig4c/'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#06-07\n", + "gatefrac=0.8\n", + "\n", + "m40_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='m40_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m40_0607_gated.append(tmp_gated)\n", + "\n", + "\n", + "m15_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='m15_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m15_0607_gated.append(tmp_gated)\n", + "\n", + "#=============+\n", + "R1_m40_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m40_0607_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m40_0607_gated.append(tmp_gated)\n", + "\n", + "\n", + "R1_m15_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m15_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m15_0607_gated.append(tmp_gated)\n", + "\n", + "#-----------\n", + "R2_m40_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_m40_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_m40_0607_gated.append(tmp_gated)\n", + "\n", + " \n", + "R2_m15_0607_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_m15_0607_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_m15_0607_gated.append(tmp_gated)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "gatefrac=0.8\n", + "\n", + "nwC1_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='nwC1_0606_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0606_gated.append(tmp_gated)\n", + "\n", + " \n", + "m7C2_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='m7C2_0606_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m7C2_0606_gated.append(tmp_gated)\n", + "\n", + "\n", + "#-------\n", + "R1_nwC1_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_nwC1_0606_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_nwC1_0606_gated.append(tmp_gated)\n", + "\n", + "\n", + "R1_m7_0606_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m7_0606_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m7_0606_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#06-05 data\n", + "gatefrac=0.8\n", + "\n", + "nwC1_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='nwC1_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC1_0605_gated.append(tmp_gated)\n", + "\n", + " \n", + "nwC2_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='nwC2_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " nwC2_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "m8_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='m8_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " m8_0605_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "R1_nwC2_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_nwC2_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_nwC2_0605_gated.append(tmp_gated)\n", + " \n", + "R1_m8_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m8_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m8_0605_gated.append(tmp_gated)\n", + " \n", + " \n", + "R1_m40_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R1_m40_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R1_m40_0605_gated.append(tmp_gated)\n", + " \n", + " \n", + "#-------\n", + "R2_nwC1_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_nwC1_0605_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_nwC1_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "R2_nwC2_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_nwC2_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_nwC2_0605_gated.append(tmp_gated)\n", + " \n", + "\n", + "R2_m8_0605_gated=[]\n", + "for i in range(0,12):\n", + " newname='R2_m8_0605_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R2_m8_0605_gated.append(tmp_gated)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# 06-04\n", + "wt_C1_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='wt_C1_0604_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " wt_C1_0604_gated.append(tmp_gated)\n", + "\n", + "wt_C2_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='wt_C2_0604_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " wt_C2_0604_gated.append(tmp_gated)\n", + "\n", + " \n", + "R_C1_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='R_C1_0604_'+str(i)+'.fcs' \n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R_C1_0604_gated.append(tmp_gated)\n", + "\n", + " \n", + "R_C2_0604_gated=[]\n", + "for i in ['A','B','C','D','E','F','G','H']:\n", + " newname='R_C2_0604_'+str(i)+'.fcs'\n", + " tmp=FC.io.FCSData(folder_+newname)\n", + " tmp_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n", + " R_C2_0604_gated.append(tmp_gated)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "#06-07\n", + "m40_0607_mch=channel_median(m40_0607_gated,'FL8-A')\n", + "m15_0607_mch=channel_median(m15_0607_gated,'FL8-A')\n", + "\n", + "R1_m40_0607_gfp=channel_median(R1_m40_0607_gated,'FL1-A')\n", + "R1_m15_0607_gfp=channel_median(R1_m15_0607_gated,'FL1-A')\n", + "\n", + "R2_m40_0607_gfp=channel_median(R2_m40_0607_gated,'FL1-A')\n", + "R2_m15_0607_gfp=channel_median(R2_m15_0607_gated,'FL1-A')\n", + "\n", + "\n", + "R1_m40_0607_bfp=channel_median(R1_m40_0607_gated,'FL5-A')\n", + "R1_m15_0607_bfp=channel_median(R1_m15_0607_gated,'FL5-A')\n", + "\n", + "R2_m40_0607_bfp=channel_median(R2_m40_0607_gated,'FL5-A')\n", + "R2_m15_0607_bfp=channel_median(R2_m15_0607_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "#06-05\n", + "nwC1_0605_mch=channel_median(nwC1_0605_gated,'FL8-A')\n", + "nwC2_0605_mch=channel_median(nwC2_0605_gated,'FL8-A')\n", + "m8_0605_mch=channel_median(m8_0605_gated,'FL8-A')\n", + "\n", + "R1_nwC2_0605_gfp=channel_median(R1_nwC2_0605_gated,'FL1-A')\n", + "R1_m8_0605_gfp=channel_median(R1_m8_0605_gated,'FL1-A')\n", + "R2_nwC1_0605_gfp=channel_median(R2_nwC1_0605_gated,'FL1-A')\n", + "R2_nwC2_0605_gfp=channel_median(R2_nwC2_0605_gated,'FL1-A')\n", + "R2_m8_0605_gfp=channel_median(R2_m8_0605_gated,'FL1-A')\n", + "R1_nwC2_0605_bfp=channel_median(R1_nwC2_0605_gated,'FL5-A')\n", + "R1_m8_0605_bfp=channel_median(R1_m8_0605_gated,'FL5-A')\n", + "R2_nwC1_0605_bfp=channel_median(R2_nwC1_0605_gated,'FL5-A')\n", + "R2_nwC2_0605_bfp=channel_median(R2_nwC2_0605_gated,'FL5-A')\n", + "R2_m8_0605_bfp=channel_median(R2_m8_0605_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#06-06\n", + "nwC1_0605_mch=channel_median(nwC1_0605_gated,'FL8-A')\n", + "nwC1_0606_mch=channel_median(nwC1_0606_gated,'FL8-A')\n", + "m7C2_0606_mch=channel_median(m7C2_0606_gated,'FL8-A')\n", + "\n", + "R1_nwC1_0606_gfp=channel_median(R1_nwC1_0606_gated,'FL1-A')\n", + "R1_m7_0606_gfp=channel_median(R1_m7_0606_gated,'FL1-A')\n", + "R1_nwC1_0606_bfp=channel_median(R1_nwC1_0606_gated,'FL5-A')\n", + "R1_m7_0606_bfp=channel_median(R1_m7_0606_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# 06-04\n", + "wtC1_0604_mch=channel_median(wt_C1_0604_gated,'FL8-A')\n", + "wtC2_0604_mch=channel_median(wt_C2_0604_gated,'FL8-A')\n", + "RC1_0604_gfp=channel_median(R_C1_0604_gated,'FL1-A')\n", + "RC2_0604_gfp=channel_median(R_C2_0604_gated,'FL1-A')\n", + "RC1_0604_bfp=channel_median(R_C1_0604_gated,'FL5-A')\n", + "RC2_0604_bfp=channel_median(R_C2_0604_gated,'FL5-A')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fitting: [1.10292919e+03 1.94584842e-02 2.15950963e+04 2.33038211e+00]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "b_range=([0,0,0,0.0],[1.5e3,0.5,3e4,5.0])\n", + "\n", + "xdata=np.concatenate((m8_0605_mch,\\\n", + " nwC1_0605_mch,nwC2_0605_mch,\\\n", + " m8_0605_mch,\\\n", + " nwC2_0605_mch,\\\n", + " nwC1_0606_mch,\\\n", + " m7C2_0606_mch,\\\n", + " wtC1_0604_mch,wtC2_0604_mch,\\\n", + " m40_0607_mch,\\\n", + " m40_0607_mch,\\\n", + " m15_0607_mch,m15_0607_mch\n", + " ))\n", + "\n", + "ydata=np.concatenate((R2_m8_0605_gfp,\\\n", + " R2_nwC1_0605_gfp,R2_nwC2_0605_gfp,\\\n", + " R1_m8_0605_gfp,\\\n", + " R1_nwC2_0605_gfp,\\\n", + " R1_nwC1_0606_gfp,\\\n", + " R1_m7_0606_gfp,\\\n", + " RC1_0604_gfp,RC2_0604_gfp,\\\n", + " R1_m40_0607_gfp,\\\n", + " R2_m40_0607_gfp,\\\n", + " R1_m15_0607_gfp,R2_m15_0607_gfp\n", + " ))\n", + "\n", + "coef_,pcov_=curve_fit(transf_pos,xdata,ydata,bounds=b_range)\n", + "print('fitting: ',coef_)\n", + "x=np.arange(100,7000,100)\n", + "R_fit=transf_pos(x,*coef_)\n", + "\n", + "#-----------------\n", + "fig=plt.figure(figsize=(6,4.5))\n", + "ax=fig.add_subplot(111)\n", + "marker_size=10\n", + "ax.scatter(xdata,ydata,label='experiment',s=marker_size,color='royalblue')\n", + "ax.plot(x,R_fit,label='fitting',color='orange')\n", + "ax.legend(loc='lower right',fontsize=15)\n", + "\n", + "ax.set_xlabel('mCherry (arb. units)',fontsize=15)\n", + "ax.set_ylabel('EYFP (arb. units)',fontsize=15)\n", + "\n", + "ax.tick_params(direction='in')\n", + "\n", + "#fig_path=''\n", + "#plt.savefig(fig_path+'R_transfcn_mch.png',dpi=400) #Fig4c\n", + "#plt.savefig(fig_path+'R_transfcn_mch.eps',format='eps') #Fig4c" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/experiment_data/Fig2b, Fig2d, Fig S24, Fig S25.ipynb b/experiment_data/Fig2b, Fig2d, Fig S24, Fig S25.ipynb index cc8fce6..8dd2727 100644 --- a/experiment_data/Fig2b, Fig2d, Fig S24, Fig S25.ipynb +++ b/experiment_data/Fig2b, Fig2d, Fig S24, Fig S25.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -134,6 +134,66 @@ "XL267_LR206_C4_aTc_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n" ] }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "tmp=FC.io.FCSData(Fig2b_folder_+'trial1_+placo_array_noaTc.fcs')\n", + "XL267C1_LB_gated=FC.gate.density2d(tmp,channels=['FSC-A','SSC-A'],bins=1000,gate_fraction=gatefrac)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Fig S31\n", + "# a demonstration for gating\n", + "fig=plt.figure(figsize=(7,3.5))\n", + "ax=fig.add_subplot(121)\n", + "#ax.set_xscale('log')\n", + "#ax.set_yscale('log')\n", + "ax.scatter(tmp[:,'FSC-A'],tmp[:,'SSC-A'],s=1)\n", + "\n", + "ax.tick_params(direction='in')\n", + "ax.tick_params(axis='x',labelsize=12)\n", + "ax.set_xlabel('FSC-A',fontsize=12.5)\n", + "ax.set_ylabel('SSC-A',fontsize=12.5)\n", + "ax.set_title('before gating', fontsize=14)\n", + "#-------------\n", + "\n", + "ax=fig.add_subplot(122)\n", + "ax.scatter(XL267C1_LB_gated[:,'FSC-A'],XL267C1_LB_gated[:,'SSC-A'],s=1)\n", + "ax.tick_params(direction='in')\n", + "ax.tick_params(axis='x',labelsize=12)\n", + "ax.set_xlabel('FSC-A',fontsize=12.5)\n", + "#ax.set_ylabel('SSC-A',fontsize=12.5)\n", + "\n", + "ax.set_title('after gating', fontsize=14)\n", + "\n", + "\n", + "#fig_path='/Users/ximing/Documents/technion_stuff/figures/rev_figures/'\n", + "#file_name='gating_effect.png'\n", + "\n", + "#fig.savefig(fig_path+file_name,dpi=400)" + ] + }, { "cell_type": "code", "execution_count": 37, diff --git a/experiment_data/Fig2e/m40_trial10_conc0.fcs b/experiment_data/Fig2e/m40_trial10_conc0.fcs index ba7955c..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc0.fcs and b/experiment_data/Fig2e/m40_trial10_conc0.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc1.fcs b/experiment_data/Fig2e/m40_trial10_conc1.fcs index a458b97..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc1.fcs and b/experiment_data/Fig2e/m40_trial10_conc1.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc10.fcs b/experiment_data/Fig2e/m40_trial10_conc10.fcs index 1672367..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc10.fcs and b/experiment_data/Fig2e/m40_trial10_conc10.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc11.fcs b/experiment_data/Fig2e/m40_trial10_conc11.fcs index e1498c3..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc11.fcs and b/experiment_data/Fig2e/m40_trial10_conc11.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc2.fcs b/experiment_data/Fig2e/m40_trial10_conc2.fcs index 43b1ded..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc2.fcs and b/experiment_data/Fig2e/m40_trial10_conc2.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc3.fcs b/experiment_data/Fig2e/m40_trial10_conc3.fcs index 18c0821..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc3.fcs and b/experiment_data/Fig2e/m40_trial10_conc3.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc4.fcs b/experiment_data/Fig2e/m40_trial10_conc4.fcs index 9d49bb5..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc4.fcs and b/experiment_data/Fig2e/m40_trial10_conc4.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc5.fcs b/experiment_data/Fig2e/m40_trial10_conc5.fcs index 8345572..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc5.fcs and b/experiment_data/Fig2e/m40_trial10_conc5.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc6.fcs b/experiment_data/Fig2e/m40_trial10_conc6.fcs index a74199d..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc6.fcs and b/experiment_data/Fig2e/m40_trial10_conc6.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc7.fcs b/experiment_data/Fig2e/m40_trial10_conc7.fcs index 15fcb30..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc7.fcs and b/experiment_data/Fig2e/m40_trial10_conc7.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc8.fcs b/experiment_data/Fig2e/m40_trial10_conc8.fcs index de0059f..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc8.fcs and b/experiment_data/Fig2e/m40_trial10_conc8.fcs differ diff --git a/experiment_data/Fig2e/m40_trial10_conc9.fcs b/experiment_data/Fig2e/m40_trial10_conc9.fcs index 8719abc..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial10_conc9.fcs and b/experiment_data/Fig2e/m40_trial10_conc9.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc0.fcs b/experiment_data/Fig2e/m40_trial11_conc0.fcs index 5da12f2..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc0.fcs and b/experiment_data/Fig2e/m40_trial11_conc0.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc1.fcs b/experiment_data/Fig2e/m40_trial11_conc1.fcs index f117da2..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc1.fcs and b/experiment_data/Fig2e/m40_trial11_conc1.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc10.fcs b/experiment_data/Fig2e/m40_trial11_conc10.fcs index 56c74b9..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc10.fcs and b/experiment_data/Fig2e/m40_trial11_conc10.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc11.fcs b/experiment_data/Fig2e/m40_trial11_conc11.fcs index 666c2fd..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc11.fcs and b/experiment_data/Fig2e/m40_trial11_conc11.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc2.fcs b/experiment_data/Fig2e/m40_trial11_conc2.fcs index cdcf572..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc2.fcs and b/experiment_data/Fig2e/m40_trial11_conc2.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc3.fcs b/experiment_data/Fig2e/m40_trial11_conc3.fcs index 2995efc..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc3.fcs and b/experiment_data/Fig2e/m40_trial11_conc3.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc4.fcs b/experiment_data/Fig2e/m40_trial11_conc4.fcs index 0dab4b4..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc4.fcs and b/experiment_data/Fig2e/m40_trial11_conc4.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc5.fcs b/experiment_data/Fig2e/m40_trial11_conc5.fcs index 2e897ed..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc5.fcs and b/experiment_data/Fig2e/m40_trial11_conc5.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc6.fcs b/experiment_data/Fig2e/m40_trial11_conc6.fcs index ea596cd..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc6.fcs and b/experiment_data/Fig2e/m40_trial11_conc6.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc7.fcs b/experiment_data/Fig2e/m40_trial11_conc7.fcs index 94a9979..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc7.fcs and b/experiment_data/Fig2e/m40_trial11_conc7.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc8.fcs b/experiment_data/Fig2e/m40_trial11_conc8.fcs index 06d7883..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc8.fcs and b/experiment_data/Fig2e/m40_trial11_conc8.fcs differ diff --git a/experiment_data/Fig2e/m40_trial11_conc9.fcs b/experiment_data/Fig2e/m40_trial11_conc9.fcs index fba2e2f..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial11_conc9.fcs and b/experiment_data/Fig2e/m40_trial11_conc9.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc0.fcs b/experiment_data/Fig2e/m40_trial9_conc0.fcs index 23e789b..2bc92ad 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc0.fcs and b/experiment_data/Fig2e/m40_trial9_conc0.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc1.fcs b/experiment_data/Fig2e/m40_trial9_conc1.fcs index 99bdf9f..9621c85 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc1.fcs and b/experiment_data/Fig2e/m40_trial9_conc1.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc10.fcs b/experiment_data/Fig2e/m40_trial9_conc10.fcs index 928d597..71b8454 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc10.fcs and b/experiment_data/Fig2e/m40_trial9_conc10.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc11.fcs b/experiment_data/Fig2e/m40_trial9_conc11.fcs index dbbeff8..8cb9a40 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc11.fcs and b/experiment_data/Fig2e/m40_trial9_conc11.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc2.fcs b/experiment_data/Fig2e/m40_trial9_conc2.fcs index 6a61fe9..17169aa 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc2.fcs and b/experiment_data/Fig2e/m40_trial9_conc2.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc3.fcs b/experiment_data/Fig2e/m40_trial9_conc3.fcs index b66923c..3b2f209 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc3.fcs and b/experiment_data/Fig2e/m40_trial9_conc3.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc4.fcs b/experiment_data/Fig2e/m40_trial9_conc4.fcs index 40be2e6..0de1e3a 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc4.fcs and b/experiment_data/Fig2e/m40_trial9_conc4.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc5.fcs b/experiment_data/Fig2e/m40_trial9_conc5.fcs index 261879a..c1bbc95 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc5.fcs and b/experiment_data/Fig2e/m40_trial9_conc5.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc6.fcs b/experiment_data/Fig2e/m40_trial9_conc6.fcs index f754fdd..5ef3295 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc6.fcs and b/experiment_data/Fig2e/m40_trial9_conc6.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc7.fcs b/experiment_data/Fig2e/m40_trial9_conc7.fcs index 25af807..4d153ea 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc7.fcs and b/experiment_data/Fig2e/m40_trial9_conc7.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc8.fcs b/experiment_data/Fig2e/m40_trial9_conc8.fcs index 6c49b59..e69b2c8 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc8.fcs and b/experiment_data/Fig2e/m40_trial9_conc8.fcs differ diff --git a/experiment_data/Fig2e/m40_trial9_conc9.fcs b/experiment_data/Fig2e/m40_trial9_conc9.fcs index 5c2daf8..7e6cdce 100644 Binary files a/experiment_data/Fig2e/m40_trial9_conc9.fcs and b/experiment_data/Fig2e/m40_trial9_conc9.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_0.fcs b/experiment_data/Fig4c/R1_m15_0607_0.fcs new file mode 100644 index 0000000..1723817 Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_0.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_1.fcs b/experiment_data/Fig4c/R1_m15_0607_1.fcs new file mode 100644 index 0000000..a024fed Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_1.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_10.fcs b/experiment_data/Fig4c/R1_m15_0607_10.fcs new file mode 100644 index 0000000..0dd4142 Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_10.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_11.fcs b/experiment_data/Fig4c/R1_m15_0607_11.fcs new file mode 100644 index 0000000..031618b Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_11.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_2.fcs b/experiment_data/Fig4c/R1_m15_0607_2.fcs new file mode 100644 index 0000000..fb45420 Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_2.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_3.fcs b/experiment_data/Fig4c/R1_m15_0607_3.fcs new file mode 100644 index 0000000..0f2a324 Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_3.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_4.fcs b/experiment_data/Fig4c/R1_m15_0607_4.fcs new file mode 100644 index 0000000..d1d5251 Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_4.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_5.fcs b/experiment_data/Fig4c/R1_m15_0607_5.fcs new file mode 100644 index 0000000..3dba63f Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_5.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_6.fcs b/experiment_data/Fig4c/R1_m15_0607_6.fcs new file mode 100644 index 0000000..1259e9e Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_6.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_7.fcs b/experiment_data/Fig4c/R1_m15_0607_7.fcs new file mode 100644 index 0000000..95ba97f Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_7.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_8.fcs b/experiment_data/Fig4c/R1_m15_0607_8.fcs new file mode 100644 index 0000000..d350b9b Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_8.fcs differ diff --git a/experiment_data/Fig4c/R1_m15_0607_9.fcs b/experiment_data/Fig4c/R1_m15_0607_9.fcs new file mode 100644 index 0000000..12be12b Binary files /dev/null and b/experiment_data/Fig4c/R1_m15_0607_9.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_0.fcs b/experiment_data/Fig4c/R1_m40_0605_0.fcs new file mode 100644 index 0000000..d643105 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_0.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_1.fcs b/experiment_data/Fig4c/R1_m40_0605_1.fcs new file mode 100644 index 0000000..1d7596c Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_1.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_10.fcs b/experiment_data/Fig4c/R1_m40_0605_10.fcs new file mode 100644 index 0000000..1c431a9 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_10.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_11.fcs b/experiment_data/Fig4c/R1_m40_0605_11.fcs new file mode 100644 index 0000000..884cd4a Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_11.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_2.fcs b/experiment_data/Fig4c/R1_m40_0605_2.fcs new file mode 100644 index 0000000..22c9f85 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_2.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_3.fcs b/experiment_data/Fig4c/R1_m40_0605_3.fcs new file mode 100644 index 0000000..7e7519f Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_3.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_4.fcs b/experiment_data/Fig4c/R1_m40_0605_4.fcs new file mode 100644 index 0000000..87a04a7 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_4.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_5.fcs b/experiment_data/Fig4c/R1_m40_0605_5.fcs new file mode 100644 index 0000000..427cc48 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_5.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_6.fcs b/experiment_data/Fig4c/R1_m40_0605_6.fcs new file mode 100644 index 0000000..beb3fab Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_6.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_7.fcs b/experiment_data/Fig4c/R1_m40_0605_7.fcs new file mode 100644 index 0000000..30452a9 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_7.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_8.fcs b/experiment_data/Fig4c/R1_m40_0605_8.fcs new file mode 100644 index 0000000..32357af Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_8.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0605_9.fcs b/experiment_data/Fig4c/R1_m40_0605_9.fcs new file mode 100644 index 0000000..f336217 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0605_9.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_0.fcs b/experiment_data/Fig4c/R1_m40_0607_0.fcs new file mode 100644 index 0000000..eca69d0 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_0.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_1.fcs b/experiment_data/Fig4c/R1_m40_0607_1.fcs new file mode 100644 index 0000000..08533e3 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_1.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_10.fcs b/experiment_data/Fig4c/R1_m40_0607_10.fcs new file mode 100644 index 0000000..054e2cc Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_10.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_11.fcs b/experiment_data/Fig4c/R1_m40_0607_11.fcs new file mode 100644 index 0000000..76631ec Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_11.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_2.fcs b/experiment_data/Fig4c/R1_m40_0607_2.fcs new file mode 100644 index 0000000..88d03a0 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_2.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_3.fcs b/experiment_data/Fig4c/R1_m40_0607_3.fcs new file mode 100644 index 0000000..16a6eba Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_3.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_4.fcs b/experiment_data/Fig4c/R1_m40_0607_4.fcs new file mode 100644 index 0000000..a4b4a0c Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_4.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_5.fcs b/experiment_data/Fig4c/R1_m40_0607_5.fcs new file mode 100644 index 0000000..12b2433 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_5.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_6.fcs b/experiment_data/Fig4c/R1_m40_0607_6.fcs new file mode 100644 index 0000000..d4a50fb Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_6.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_7.fcs b/experiment_data/Fig4c/R1_m40_0607_7.fcs new file mode 100644 index 0000000..84b99cf Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_7.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_8.fcs b/experiment_data/Fig4c/R1_m40_0607_8.fcs new file mode 100644 index 0000000..fdf5092 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_8.fcs differ diff --git a/experiment_data/Fig4c/R1_m40_0607_9.fcs b/experiment_data/Fig4c/R1_m40_0607_9.fcs new file mode 100644 index 0000000..1fdc6f0 Binary files /dev/null and b/experiment_data/Fig4c/R1_m40_0607_9.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_0.fcs b/experiment_data/Fig4c/R1_m7_0606_0.fcs new file mode 100644 index 0000000..73c8266 Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_0.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_1.fcs b/experiment_data/Fig4c/R1_m7_0606_1.fcs new file mode 100644 index 0000000..fca83ed Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_1.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_10.fcs b/experiment_data/Fig4c/R1_m7_0606_10.fcs new file mode 100644 index 0000000..448e081 Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_10.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_11.fcs b/experiment_data/Fig4c/R1_m7_0606_11.fcs new file mode 100644 index 0000000..798926c Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_11.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_2.fcs b/experiment_data/Fig4c/R1_m7_0606_2.fcs new file mode 100644 index 0000000..f28485a Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_2.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_3.fcs b/experiment_data/Fig4c/R1_m7_0606_3.fcs new file mode 100644 index 0000000..dd85fae Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_3.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_4.fcs b/experiment_data/Fig4c/R1_m7_0606_4.fcs new file mode 100644 index 0000000..68f0335 Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_4.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_5.fcs b/experiment_data/Fig4c/R1_m7_0606_5.fcs new file mode 100644 index 0000000..a62034b Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_5.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_6.fcs b/experiment_data/Fig4c/R1_m7_0606_6.fcs new file mode 100644 index 0000000..f367151 Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_6.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_7.fcs b/experiment_data/Fig4c/R1_m7_0606_7.fcs new file mode 100644 index 0000000..fb94168 Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_7.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_8.fcs b/experiment_data/Fig4c/R1_m7_0606_8.fcs new file mode 100644 index 0000000..92b83e1 Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_8.fcs differ diff --git a/experiment_data/Fig4c/R1_m7_0606_9.fcs b/experiment_data/Fig4c/R1_m7_0606_9.fcs new file mode 100644 index 0000000..dacba82 Binary files /dev/null and b/experiment_data/Fig4c/R1_m7_0606_9.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_0.fcs b/experiment_data/Fig4c/R1_m8_0605_0.fcs new file mode 100644 index 0000000..52ae365 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_0.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_1.fcs b/experiment_data/Fig4c/R1_m8_0605_1.fcs new file mode 100644 index 0000000..0c7b74d Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_1.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_10.fcs b/experiment_data/Fig4c/R1_m8_0605_10.fcs new file mode 100644 index 0000000..b54e9e3 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_10.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_11.fcs b/experiment_data/Fig4c/R1_m8_0605_11.fcs new file mode 100644 index 0000000..365746f Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_11.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_2.fcs b/experiment_data/Fig4c/R1_m8_0605_2.fcs new file mode 100644 index 0000000..cedcf38 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_2.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_3.fcs b/experiment_data/Fig4c/R1_m8_0605_3.fcs new file mode 100644 index 0000000..e462f85 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_3.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_4.fcs b/experiment_data/Fig4c/R1_m8_0605_4.fcs new file mode 100644 index 0000000..bd45089 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_4.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_5.fcs b/experiment_data/Fig4c/R1_m8_0605_5.fcs new file mode 100644 index 0000000..9c05880 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_5.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_6.fcs b/experiment_data/Fig4c/R1_m8_0605_6.fcs new file mode 100644 index 0000000..5845dfe Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_6.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_7.fcs b/experiment_data/Fig4c/R1_m8_0605_7.fcs new file mode 100644 index 0000000..7533cf9 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_7.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_8.fcs b/experiment_data/Fig4c/R1_m8_0605_8.fcs new file mode 100644 index 0000000..a1cd466 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_8.fcs differ diff --git a/experiment_data/Fig4c/R1_m8_0605_9.fcs b/experiment_data/Fig4c/R1_m8_0605_9.fcs new file mode 100644 index 0000000..564ae02 Binary files /dev/null and b/experiment_data/Fig4c/R1_m8_0605_9.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_0.fcs b/experiment_data/Fig4c/R1_nwC1_0606_0.fcs new file mode 100644 index 0000000..0f50b5b Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_0.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_1.fcs b/experiment_data/Fig4c/R1_nwC1_0606_1.fcs new file mode 100644 index 0000000..990264e Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_1.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_10.fcs b/experiment_data/Fig4c/R1_nwC1_0606_10.fcs new file mode 100644 index 0000000..95f8f12 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_10.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_11.fcs b/experiment_data/Fig4c/R1_nwC1_0606_11.fcs new file mode 100644 index 0000000..cf16adc Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_11.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_2.fcs b/experiment_data/Fig4c/R1_nwC1_0606_2.fcs new file mode 100644 index 0000000..f5bf4a2 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_2.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_3.fcs b/experiment_data/Fig4c/R1_nwC1_0606_3.fcs new file mode 100644 index 0000000..1ac5e9a Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_3.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_4.fcs b/experiment_data/Fig4c/R1_nwC1_0606_4.fcs new file mode 100644 index 0000000..0bf584e Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_4.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_5.fcs b/experiment_data/Fig4c/R1_nwC1_0606_5.fcs new file mode 100644 index 0000000..114b14c Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_5.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_6.fcs b/experiment_data/Fig4c/R1_nwC1_0606_6.fcs new file mode 100644 index 0000000..d35eacf Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_6.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_7.fcs b/experiment_data/Fig4c/R1_nwC1_0606_7.fcs new file mode 100644 index 0000000..92a9325 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_7.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_8.fcs b/experiment_data/Fig4c/R1_nwC1_0606_8.fcs new file mode 100644 index 0000000..ce63c68 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_8.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC1_0606_9.fcs b/experiment_data/Fig4c/R1_nwC1_0606_9.fcs new file mode 100644 index 0000000..4862373 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC1_0606_9.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_0.fcs b/experiment_data/Fig4c/R1_nwC2_0605_0.fcs new file mode 100644 index 0000000..deea36f Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_0.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_1.fcs b/experiment_data/Fig4c/R1_nwC2_0605_1.fcs new file mode 100644 index 0000000..a33f0ef Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_1.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_10.fcs b/experiment_data/Fig4c/R1_nwC2_0605_10.fcs new file mode 100644 index 0000000..181437c Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_10.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_11.fcs b/experiment_data/Fig4c/R1_nwC2_0605_11.fcs new file mode 100644 index 0000000..ab8a4b2 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_11.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_2.fcs b/experiment_data/Fig4c/R1_nwC2_0605_2.fcs new file mode 100644 index 0000000..4d7b5fd Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_2.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_3.fcs b/experiment_data/Fig4c/R1_nwC2_0605_3.fcs new file mode 100644 index 0000000..f225766 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_3.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_4.fcs b/experiment_data/Fig4c/R1_nwC2_0605_4.fcs new file mode 100644 index 0000000..4d7d7e8 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_4.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_5.fcs b/experiment_data/Fig4c/R1_nwC2_0605_5.fcs new file mode 100644 index 0000000..7b8a0f5 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_5.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_6.fcs b/experiment_data/Fig4c/R1_nwC2_0605_6.fcs new file mode 100644 index 0000000..8ef48c5 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_6.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_7.fcs b/experiment_data/Fig4c/R1_nwC2_0605_7.fcs new file mode 100644 index 0000000..fffb8f4 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_7.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_8.fcs b/experiment_data/Fig4c/R1_nwC2_0605_8.fcs new file mode 100644 index 0000000..ab3cee2 Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_8.fcs differ diff --git a/experiment_data/Fig4c/R1_nwC2_0605_9.fcs b/experiment_data/Fig4c/R1_nwC2_0605_9.fcs new file mode 100644 index 0000000..be6b69b Binary files /dev/null and b/experiment_data/Fig4c/R1_nwC2_0605_9.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_0.fcs b/experiment_data/Fig4c/R2_m15_0607_0.fcs new file mode 100644 index 0000000..cc729dc Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_0.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_1.fcs b/experiment_data/Fig4c/R2_m15_0607_1.fcs new file mode 100644 index 0000000..9f77c4e Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_1.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_10.fcs b/experiment_data/Fig4c/R2_m15_0607_10.fcs new file mode 100644 index 0000000..cbc6e14 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_10.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_11.fcs b/experiment_data/Fig4c/R2_m15_0607_11.fcs new file mode 100644 index 0000000..4a184b7 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_11.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_2.fcs b/experiment_data/Fig4c/R2_m15_0607_2.fcs new file mode 100644 index 0000000..6d78972 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_2.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_3.fcs b/experiment_data/Fig4c/R2_m15_0607_3.fcs new file mode 100644 index 0000000..89763b0 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_3.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_4.fcs b/experiment_data/Fig4c/R2_m15_0607_4.fcs new file mode 100644 index 0000000..ae1ca13 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_4.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_5.fcs b/experiment_data/Fig4c/R2_m15_0607_5.fcs new file mode 100644 index 0000000..b95822b Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_5.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_6.fcs b/experiment_data/Fig4c/R2_m15_0607_6.fcs new file mode 100644 index 0000000..c5e0a25 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_6.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_7.fcs b/experiment_data/Fig4c/R2_m15_0607_7.fcs new file mode 100644 index 0000000..b4e3e27 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_7.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_8.fcs b/experiment_data/Fig4c/R2_m15_0607_8.fcs new file mode 100644 index 0000000..3d4da46 Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_8.fcs differ diff --git a/experiment_data/Fig4c/R2_m15_0607_9.fcs b/experiment_data/Fig4c/R2_m15_0607_9.fcs new file mode 100644 index 0000000..163156f Binary files /dev/null and b/experiment_data/Fig4c/R2_m15_0607_9.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_0.fcs b/experiment_data/Fig4c/R2_m40_0607_0.fcs new file mode 100644 index 0000000..1d0bcf7 Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_0.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_1.fcs b/experiment_data/Fig4c/R2_m40_0607_1.fcs new file mode 100644 index 0000000..b631a7a Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_1.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_10.fcs b/experiment_data/Fig4c/R2_m40_0607_10.fcs new file mode 100644 index 0000000..61c769d Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_10.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_11.fcs b/experiment_data/Fig4c/R2_m40_0607_11.fcs new file mode 100644 index 0000000..879e70f Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_11.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_2.fcs b/experiment_data/Fig4c/R2_m40_0607_2.fcs new file mode 100644 index 0000000..b0255f4 Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_2.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_3.fcs b/experiment_data/Fig4c/R2_m40_0607_3.fcs new file mode 100644 index 0000000..f06ed17 Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_3.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_4.fcs b/experiment_data/Fig4c/R2_m40_0607_4.fcs new file mode 100644 index 0000000..d94ce37 Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_4.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_5.fcs b/experiment_data/Fig4c/R2_m40_0607_5.fcs new file mode 100644 index 0000000..74bbc30 Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_5.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_6.fcs b/experiment_data/Fig4c/R2_m40_0607_6.fcs new file mode 100644 index 0000000..6e6c9be Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_6.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_7.fcs b/experiment_data/Fig4c/R2_m40_0607_7.fcs new file mode 100644 index 0000000..69e4f5c Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_7.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_8.fcs b/experiment_data/Fig4c/R2_m40_0607_8.fcs new file mode 100644 index 0000000..450085c Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_8.fcs differ diff --git a/experiment_data/Fig4c/R2_m40_0607_9.fcs b/experiment_data/Fig4c/R2_m40_0607_9.fcs new file mode 100644 index 0000000..f819f9f Binary files /dev/null and b/experiment_data/Fig4c/R2_m40_0607_9.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_0.fcs b/experiment_data/Fig4c/R2_m8_0605_0.fcs new file mode 100644 index 0000000..ff0dee8 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_0.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_1.fcs b/experiment_data/Fig4c/R2_m8_0605_1.fcs new file mode 100644 index 0000000..459e436 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_1.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_10.fcs b/experiment_data/Fig4c/R2_m8_0605_10.fcs new file mode 100644 index 0000000..b4f2373 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_10.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_11.fcs b/experiment_data/Fig4c/R2_m8_0605_11.fcs new file mode 100644 index 0000000..d216e94 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_11.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_2.fcs b/experiment_data/Fig4c/R2_m8_0605_2.fcs new file mode 100644 index 0000000..949c4d2 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_2.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_3.fcs b/experiment_data/Fig4c/R2_m8_0605_3.fcs new file mode 100644 index 0000000..5f17ebb Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_3.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_4.fcs b/experiment_data/Fig4c/R2_m8_0605_4.fcs new file mode 100644 index 0000000..f4ac46d Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_4.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_5.fcs b/experiment_data/Fig4c/R2_m8_0605_5.fcs new file mode 100644 index 0000000..6c5383b Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_5.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_6.fcs b/experiment_data/Fig4c/R2_m8_0605_6.fcs new file mode 100644 index 0000000..a78b218 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_6.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_7.fcs b/experiment_data/Fig4c/R2_m8_0605_7.fcs new file mode 100644 index 0000000..d905056 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_7.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_8.fcs b/experiment_data/Fig4c/R2_m8_0605_8.fcs new file mode 100644 index 0000000..dbb3546 Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_8.fcs differ diff --git a/experiment_data/Fig4c/R2_m8_0605_9.fcs b/experiment_data/Fig4c/R2_m8_0605_9.fcs new file mode 100644 index 0000000..a44a56b Binary files /dev/null and b/experiment_data/Fig4c/R2_m8_0605_9.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_0.fcs b/experiment_data/Fig4c/R2_nwC1_0605_0.fcs new file mode 100644 index 0000000..c2b0509 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_0.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_1.fcs b/experiment_data/Fig4c/R2_nwC1_0605_1.fcs new file mode 100644 index 0000000..8a1bdfd Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_1.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_10.fcs b/experiment_data/Fig4c/R2_nwC1_0605_10.fcs new file mode 100644 index 0000000..6138740 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_10.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_11.fcs b/experiment_data/Fig4c/R2_nwC1_0605_11.fcs new file mode 100644 index 0000000..794bd01 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_11.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_2.fcs b/experiment_data/Fig4c/R2_nwC1_0605_2.fcs new file mode 100644 index 0000000..ef3a2ee Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_2.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_3.fcs b/experiment_data/Fig4c/R2_nwC1_0605_3.fcs new file mode 100644 index 0000000..aa3d060 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_3.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_4.fcs b/experiment_data/Fig4c/R2_nwC1_0605_4.fcs new file mode 100644 index 0000000..a7e3e9a Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_4.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_5.fcs b/experiment_data/Fig4c/R2_nwC1_0605_5.fcs new file mode 100644 index 0000000..cf0223c Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_5.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_6.fcs b/experiment_data/Fig4c/R2_nwC1_0605_6.fcs new file mode 100644 index 0000000..69248c5 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_6.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_7.fcs b/experiment_data/Fig4c/R2_nwC1_0605_7.fcs new file mode 100644 index 0000000..cab8651 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_7.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_8.fcs b/experiment_data/Fig4c/R2_nwC1_0605_8.fcs new file mode 100644 index 0000000..5db991e Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_8.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC1_0605_9.fcs b/experiment_data/Fig4c/R2_nwC1_0605_9.fcs new file mode 100644 index 0000000..b4d479c Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC1_0605_9.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_0.fcs b/experiment_data/Fig4c/R2_nwC2_0605_0.fcs new file mode 100644 index 0000000..3f536d9 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_0.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_1.fcs b/experiment_data/Fig4c/R2_nwC2_0605_1.fcs new file mode 100644 index 0000000..ee90fe6 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_1.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_10.fcs b/experiment_data/Fig4c/R2_nwC2_0605_10.fcs new file mode 100644 index 0000000..5dc5d96 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_10.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_11.fcs b/experiment_data/Fig4c/R2_nwC2_0605_11.fcs new file mode 100644 index 0000000..a2032e0 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_11.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_2.fcs b/experiment_data/Fig4c/R2_nwC2_0605_2.fcs new file mode 100644 index 0000000..5546118 Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_2.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_3.fcs b/experiment_data/Fig4c/R2_nwC2_0605_3.fcs new file mode 100644 index 0000000..f54d3eb Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_3.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_4.fcs b/experiment_data/Fig4c/R2_nwC2_0605_4.fcs new file mode 100644 index 0000000..c412dbf Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_4.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_5.fcs b/experiment_data/Fig4c/R2_nwC2_0605_5.fcs new file mode 100644 index 0000000..764d5ac Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_5.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_6.fcs b/experiment_data/Fig4c/R2_nwC2_0605_6.fcs new file mode 100644 index 0000000..314968b Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_6.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_7.fcs b/experiment_data/Fig4c/R2_nwC2_0605_7.fcs new file mode 100644 index 0000000..e8406ef Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_7.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_8.fcs b/experiment_data/Fig4c/R2_nwC2_0605_8.fcs new file mode 100644 index 0000000..f378d6a Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_8.fcs differ diff --git a/experiment_data/Fig4c/R2_nwC2_0605_9.fcs b/experiment_data/Fig4c/R2_nwC2_0605_9.fcs new file mode 100644 index 0000000..2a853ec Binary files /dev/null and b/experiment_data/Fig4c/R2_nwC2_0605_9.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_A.fcs b/experiment_data/Fig4c/R_C1_0604_A.fcs new file mode 100644 index 0000000..2e42284 Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_A.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_B.fcs b/experiment_data/Fig4c/R_C1_0604_B.fcs new file mode 100644 index 0000000..358c398 Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_B.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_C.fcs b/experiment_data/Fig4c/R_C1_0604_C.fcs new file mode 100644 index 0000000..9e487e6 Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_C.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_D.fcs b/experiment_data/Fig4c/R_C1_0604_D.fcs new file mode 100644 index 0000000..7d922ef Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_D.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_E.fcs b/experiment_data/Fig4c/R_C1_0604_E.fcs new file mode 100644 index 0000000..8893440 Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_E.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_F.fcs b/experiment_data/Fig4c/R_C1_0604_F.fcs new file mode 100644 index 0000000..05668d1 Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_F.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_G.fcs b/experiment_data/Fig4c/R_C1_0604_G.fcs new file mode 100644 index 0000000..65c9f65 Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_G.fcs differ diff --git a/experiment_data/Fig4c/R_C1_0604_H.fcs b/experiment_data/Fig4c/R_C1_0604_H.fcs new file mode 100644 index 0000000..5632e76 Binary files /dev/null and b/experiment_data/Fig4c/R_C1_0604_H.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_A.fcs b/experiment_data/Fig4c/R_C2_0604_A.fcs new file mode 100644 index 0000000..82a4c86 Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_A.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_B.fcs b/experiment_data/Fig4c/R_C2_0604_B.fcs new file mode 100644 index 0000000..6be3665 Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_B.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_C.fcs b/experiment_data/Fig4c/R_C2_0604_C.fcs new file mode 100644 index 0000000..6c0f033 Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_C.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_D.fcs b/experiment_data/Fig4c/R_C2_0604_D.fcs new file mode 100644 index 0000000..294a9b4 Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_D.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_E.fcs b/experiment_data/Fig4c/R_C2_0604_E.fcs new file mode 100644 index 0000000..0f88a98 Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_E.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_F.fcs b/experiment_data/Fig4c/R_C2_0604_F.fcs new file mode 100644 index 0000000..44550c9 Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_F.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_G.fcs b/experiment_data/Fig4c/R_C2_0604_G.fcs new file mode 100644 index 0000000..d37f1e7 Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_G.fcs differ diff --git a/experiment_data/Fig4c/R_C2_0604_H.fcs b/experiment_data/Fig4c/R_C2_0604_H.fcs new file mode 100644 index 0000000..2e4e65b Binary files /dev/null and b/experiment_data/Fig4c/R_C2_0604_H.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_0.fcs b/experiment_data/Fig4c/m15_0607_0.fcs new file mode 100644 index 0000000..26347c4 Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_0.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_1.fcs b/experiment_data/Fig4c/m15_0607_1.fcs new file mode 100644 index 0000000..af863c0 Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_1.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_10.fcs b/experiment_data/Fig4c/m15_0607_10.fcs new file mode 100644 index 0000000..354481f Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_10.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_11.fcs b/experiment_data/Fig4c/m15_0607_11.fcs new file mode 100644 index 0000000..a0e392c Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_11.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_2.fcs b/experiment_data/Fig4c/m15_0607_2.fcs new file mode 100644 index 0000000..6cac998 Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_2.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_3.fcs b/experiment_data/Fig4c/m15_0607_3.fcs new file mode 100644 index 0000000..f8cc54c Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_3.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_4.fcs b/experiment_data/Fig4c/m15_0607_4.fcs new file mode 100644 index 0000000..30141d0 Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_4.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_5.fcs b/experiment_data/Fig4c/m15_0607_5.fcs new file mode 100644 index 0000000..1635044 Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_5.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_6.fcs b/experiment_data/Fig4c/m15_0607_6.fcs new file mode 100644 index 0000000..5fee00c Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_6.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_7.fcs b/experiment_data/Fig4c/m15_0607_7.fcs new file mode 100644 index 0000000..197cd57 Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_7.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_8.fcs b/experiment_data/Fig4c/m15_0607_8.fcs new file mode 100644 index 0000000..bce5d3a Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_8.fcs differ diff --git a/experiment_data/Fig4c/m15_0607_9.fcs b/experiment_data/Fig4c/m15_0607_9.fcs new file mode 100644 index 0000000..1660a5a Binary files /dev/null and b/experiment_data/Fig4c/m15_0607_9.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_0.fcs b/experiment_data/Fig4c/m40_0607_0.fcs new file mode 100644 index 0000000..4fa3e13 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_0.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_1.fcs b/experiment_data/Fig4c/m40_0607_1.fcs new file mode 100644 index 0000000..05fc41c Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_1.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_10.fcs b/experiment_data/Fig4c/m40_0607_10.fcs new file mode 100644 index 0000000..a637519 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_10.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_11.fcs b/experiment_data/Fig4c/m40_0607_11.fcs new file mode 100644 index 0000000..fe213ea Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_11.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_2.fcs b/experiment_data/Fig4c/m40_0607_2.fcs new file mode 100644 index 0000000..a0058ca Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_2.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_3.fcs b/experiment_data/Fig4c/m40_0607_3.fcs new file mode 100644 index 0000000..63ecc95 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_3.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_4.fcs b/experiment_data/Fig4c/m40_0607_4.fcs new file mode 100644 index 0000000..96150ab Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_4.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_5.fcs b/experiment_data/Fig4c/m40_0607_5.fcs new file mode 100644 index 0000000..1c64309 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_5.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_6.fcs b/experiment_data/Fig4c/m40_0607_6.fcs new file mode 100644 index 0000000..fed8140 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_6.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_7.fcs b/experiment_data/Fig4c/m40_0607_7.fcs new file mode 100644 index 0000000..afec612 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_7.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_8.fcs b/experiment_data/Fig4c/m40_0607_8.fcs new file mode 100644 index 0000000..ae2d889 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_8.fcs differ diff --git a/experiment_data/Fig4c/m40_0607_9.fcs b/experiment_data/Fig4c/m40_0607_9.fcs new file mode 100644 index 0000000..a7ede90 Binary files /dev/null and b/experiment_data/Fig4c/m40_0607_9.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_0.fcs b/experiment_data/Fig4c/m7C2_0606_0.fcs new file mode 100644 index 0000000..b5fe6e5 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_0.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_1.fcs b/experiment_data/Fig4c/m7C2_0606_1.fcs new file mode 100644 index 0000000..04c360a Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_1.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_10.fcs b/experiment_data/Fig4c/m7C2_0606_10.fcs new file mode 100644 index 0000000..65c87bf Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_10.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_11.fcs b/experiment_data/Fig4c/m7C2_0606_11.fcs new file mode 100644 index 0000000..3a58688 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_11.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_2.fcs b/experiment_data/Fig4c/m7C2_0606_2.fcs new file mode 100644 index 0000000..b13fe43 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_2.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_3.fcs b/experiment_data/Fig4c/m7C2_0606_3.fcs new file mode 100644 index 0000000..4d7d6a4 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_3.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_4.fcs b/experiment_data/Fig4c/m7C2_0606_4.fcs new file mode 100644 index 0000000..2edb8a0 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_4.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_5.fcs b/experiment_data/Fig4c/m7C2_0606_5.fcs new file mode 100644 index 0000000..fe950d8 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_5.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_6.fcs b/experiment_data/Fig4c/m7C2_0606_6.fcs new file mode 100644 index 0000000..03aac65 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_6.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_7.fcs b/experiment_data/Fig4c/m7C2_0606_7.fcs new file mode 100644 index 0000000..b63b1ba Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_7.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_8.fcs b/experiment_data/Fig4c/m7C2_0606_8.fcs new file mode 100644 index 0000000..cbd4293 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_8.fcs differ diff --git a/experiment_data/Fig4c/m7C2_0606_9.fcs b/experiment_data/Fig4c/m7C2_0606_9.fcs new file mode 100644 index 0000000..f7aecb1 Binary files /dev/null and b/experiment_data/Fig4c/m7C2_0606_9.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_0.fcs b/experiment_data/Fig4c/m8_0605_0.fcs new file mode 100644 index 0000000..9ceb50a Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_0.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_1.fcs b/experiment_data/Fig4c/m8_0605_1.fcs new file mode 100644 index 0000000..803e6e0 Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_1.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_10.fcs b/experiment_data/Fig4c/m8_0605_10.fcs new file mode 100644 index 0000000..16131ce Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_10.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_11.fcs b/experiment_data/Fig4c/m8_0605_11.fcs new file mode 100644 index 0000000..90a7f67 Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_11.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_2.fcs b/experiment_data/Fig4c/m8_0605_2.fcs new file mode 100644 index 0000000..346663a Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_2.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_3.fcs b/experiment_data/Fig4c/m8_0605_3.fcs new file mode 100644 index 0000000..51ae710 Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_3.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_4.fcs b/experiment_data/Fig4c/m8_0605_4.fcs new file mode 100644 index 0000000..b8ccf0d Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_4.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_5.fcs b/experiment_data/Fig4c/m8_0605_5.fcs new file mode 100644 index 0000000..da9b279 Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_5.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_6.fcs b/experiment_data/Fig4c/m8_0605_6.fcs new file mode 100644 index 0000000..6a0be0c Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_6.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_7.fcs b/experiment_data/Fig4c/m8_0605_7.fcs new file mode 100644 index 0000000..326f66b Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_7.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_8.fcs b/experiment_data/Fig4c/m8_0605_8.fcs new file mode 100644 index 0000000..9b99792 Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_8.fcs differ diff --git a/experiment_data/Fig4c/m8_0605_9.fcs b/experiment_data/Fig4c/m8_0605_9.fcs new file mode 100644 index 0000000..f490011 Binary files /dev/null and b/experiment_data/Fig4c/m8_0605_9.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_0.fcs b/experiment_data/Fig4c/nwC1_0605_0.fcs new file mode 100644 index 0000000..11ef881 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_0.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_1.fcs b/experiment_data/Fig4c/nwC1_0605_1.fcs new file mode 100644 index 0000000..cc9dea1 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_1.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_10.fcs b/experiment_data/Fig4c/nwC1_0605_10.fcs new file mode 100644 index 0000000..1c53f9d Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_10.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_11.fcs b/experiment_data/Fig4c/nwC1_0605_11.fcs new file mode 100644 index 0000000..a90057a Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_11.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_2.fcs b/experiment_data/Fig4c/nwC1_0605_2.fcs new file mode 100644 index 0000000..d7af238 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_2.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_3.fcs b/experiment_data/Fig4c/nwC1_0605_3.fcs new file mode 100644 index 0000000..8929fd0 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_3.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_4.fcs b/experiment_data/Fig4c/nwC1_0605_4.fcs new file mode 100644 index 0000000..b5b30ed Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_4.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_5.fcs b/experiment_data/Fig4c/nwC1_0605_5.fcs new file mode 100644 index 0000000..048f89b Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_5.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_6.fcs b/experiment_data/Fig4c/nwC1_0605_6.fcs new file mode 100644 index 0000000..ee9396c Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_6.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_7.fcs b/experiment_data/Fig4c/nwC1_0605_7.fcs new file mode 100644 index 0000000..fc826d6 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_7.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_8.fcs b/experiment_data/Fig4c/nwC1_0605_8.fcs new file mode 100644 index 0000000..5f9e66e Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_8.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0605_9.fcs b/experiment_data/Fig4c/nwC1_0605_9.fcs new file mode 100644 index 0000000..4c49db2 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0605_9.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_0.fcs b/experiment_data/Fig4c/nwC1_0606_0.fcs new file mode 100644 index 0000000..d18e9f8 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_0.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_1.fcs b/experiment_data/Fig4c/nwC1_0606_1.fcs new file mode 100644 index 0000000..93709be Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_1.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_10.fcs b/experiment_data/Fig4c/nwC1_0606_10.fcs new file mode 100644 index 0000000..29778b7 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_10.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_11.fcs b/experiment_data/Fig4c/nwC1_0606_11.fcs new file mode 100644 index 0000000..d566ac8 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_11.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_2.fcs b/experiment_data/Fig4c/nwC1_0606_2.fcs new file mode 100644 index 0000000..deefc36 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_2.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_3.fcs b/experiment_data/Fig4c/nwC1_0606_3.fcs new file mode 100644 index 0000000..7d818e5 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_3.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_4.fcs b/experiment_data/Fig4c/nwC1_0606_4.fcs new file mode 100644 index 0000000..1b7d6e3 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_4.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_5.fcs b/experiment_data/Fig4c/nwC1_0606_5.fcs new file mode 100644 index 0000000..27ac811 Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_5.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_6.fcs b/experiment_data/Fig4c/nwC1_0606_6.fcs new file mode 100644 index 0000000..dd95c5e Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_6.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_7.fcs b/experiment_data/Fig4c/nwC1_0606_7.fcs new file mode 100644 index 0000000..45c428d Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_7.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_8.fcs b/experiment_data/Fig4c/nwC1_0606_8.fcs new file mode 100644 index 0000000..6e485ae Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_8.fcs differ diff --git a/experiment_data/Fig4c/nwC1_0606_9.fcs b/experiment_data/Fig4c/nwC1_0606_9.fcs new file mode 100644 index 0000000..f55913a Binary files /dev/null and b/experiment_data/Fig4c/nwC1_0606_9.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_0.fcs b/experiment_data/Fig4c/nwC2_0605_0.fcs new file mode 100644 index 0000000..4fc5738 Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_0.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_1.fcs b/experiment_data/Fig4c/nwC2_0605_1.fcs new file mode 100644 index 0000000..eef5514 Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_1.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_10.fcs b/experiment_data/Fig4c/nwC2_0605_10.fcs new file mode 100644 index 0000000..b521c75 Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_10.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_11.fcs b/experiment_data/Fig4c/nwC2_0605_11.fcs new file mode 100644 index 0000000..715ae19 Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_11.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_2.fcs b/experiment_data/Fig4c/nwC2_0605_2.fcs new file mode 100644 index 0000000..1adc8af Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_2.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_3.fcs b/experiment_data/Fig4c/nwC2_0605_3.fcs new file mode 100644 index 0000000..98043cc Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_3.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_4.fcs b/experiment_data/Fig4c/nwC2_0605_4.fcs new file mode 100644 index 0000000..e7070eb Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_4.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_5.fcs b/experiment_data/Fig4c/nwC2_0605_5.fcs new file mode 100644 index 0000000..03e577c Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_5.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_6.fcs b/experiment_data/Fig4c/nwC2_0605_6.fcs new file mode 100644 index 0000000..bf45878 Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_6.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_7.fcs b/experiment_data/Fig4c/nwC2_0605_7.fcs new file mode 100644 index 0000000..9892756 Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_7.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_8.fcs b/experiment_data/Fig4c/nwC2_0605_8.fcs new file mode 100644 index 0000000..750c488 Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_8.fcs differ diff --git a/experiment_data/Fig4c/nwC2_0605_9.fcs b/experiment_data/Fig4c/nwC2_0605_9.fcs new file mode 100644 index 0000000..73bd16b Binary files /dev/null and b/experiment_data/Fig4c/nwC2_0605_9.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_A.fcs b/experiment_data/Fig4c/wt_C1_0604_A.fcs new file mode 100644 index 0000000..4bb14e9 Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_A.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_B.fcs b/experiment_data/Fig4c/wt_C1_0604_B.fcs new file mode 100644 index 0000000..d043f48 Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_B.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_C.fcs b/experiment_data/Fig4c/wt_C1_0604_C.fcs new file mode 100644 index 0000000..60a7a61 Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_C.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_D.fcs b/experiment_data/Fig4c/wt_C1_0604_D.fcs new file mode 100644 index 0000000..9e71182 Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_D.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_E.fcs b/experiment_data/Fig4c/wt_C1_0604_E.fcs new file mode 100644 index 0000000..8187a34 Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_E.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_F.fcs b/experiment_data/Fig4c/wt_C1_0604_F.fcs new file mode 100644 index 0000000..ab65a89 Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_F.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_G.fcs b/experiment_data/Fig4c/wt_C1_0604_G.fcs new file mode 100644 index 0000000..5bdc4d9 Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_G.fcs differ diff --git a/experiment_data/Fig4c/wt_C1_0604_H.fcs b/experiment_data/Fig4c/wt_C1_0604_H.fcs new file mode 100644 index 0000000..0fda23e Binary files /dev/null and b/experiment_data/Fig4c/wt_C1_0604_H.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_A.fcs b/experiment_data/Fig4c/wt_C2_0604_A.fcs new file mode 100644 index 0000000..98e1a50 Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_A.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_B.fcs b/experiment_data/Fig4c/wt_C2_0604_B.fcs new file mode 100644 index 0000000..82b1d7c Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_B.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_C.fcs b/experiment_data/Fig4c/wt_C2_0604_C.fcs new file mode 100644 index 0000000..c3d5559 Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_C.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_D.fcs b/experiment_data/Fig4c/wt_C2_0604_D.fcs new file mode 100644 index 0000000..ee36e64 Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_D.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_E.fcs b/experiment_data/Fig4c/wt_C2_0604_E.fcs new file mode 100644 index 0000000..17b58d8 Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_E.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_F.fcs b/experiment_data/Fig4c/wt_C2_0604_F.fcs new file mode 100644 index 0000000..fb8b714 Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_F.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_G.fcs b/experiment_data/Fig4c/wt_C2_0604_G.fcs new file mode 100644 index 0000000..56be8ea Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_G.fcs differ diff --git a/experiment_data/Fig4c/wt_C2_0604_H.fcs b/experiment_data/Fig4c/wt_C2_0604_H.fcs new file mode 100644 index 0000000..01c0c40 Binary files /dev/null and b/experiment_data/Fig4c/wt_C2_0604_H.fcs differ