data_tickle-220713.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import matplotlib\n",
    "from matplotlib import pylab, mlab, pyplot\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "np = numpy\n",
    "plt = pyplot\n",
    "\n",
    "from pylab import *\n",
    "from numpy import *\n",
    "# import PyQt5 #works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.signal import argrelextrema, argrelmin, find_peaks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import glob\n",
    "from matplotlib import cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: Qt5Agg\n"
     ]
    }
   ],
   "source": [
    "%matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %matplotlib qt\n",
    "matplotlib.rcParams['figure.figsize'] = [10.5,7]\n",
    "matplotlib.rcParams.update({'font.size': 20})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def beta_continue_alamano(a,q,beta_guess): #a l'air ok\n",
    "    C1 = q**2/( (beta_guess+2)**2 - a - q**2/( (beta_guess+4)**2 - a - q**2/( (beta_guess+6)**2 - a - q**2/( (beta_guess+8)**2 - a - q**2/( (beta_guess+10)**2 - a ) ) ) ) )\n",
    "    C2 = q**2/( (beta_guess-2)**2 - a - q**2/( (beta_guess-4)**2 - a - q**2/( (beta_guess-6)**2 - a - q**2/( (beta_guess-8)**2 - a - q**2/( (beta_guess-10)**2 - a  ) ) ) ) )\n",
    "    return a + C1 + C2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$\\kappa_{simion}$ = 0.270471\n"
     ]
    }
   ],
   "source": [
    "# Constantes de la physique\n",
    "# ABSOLUMENT RECHARGER APRÈS AVOIR EXECUTÉ LES CASES D'IMPORT AU DESSUS\n",
    "\n",
    "C_e = 1.602e-19        # Coulomb\n",
    "kb = 1.38064852*1e-23  # Boltzman\n",
    "m_Ca = 40.078*1.66054e-27 # masse Ca 40.078\n",
    "m_GM = 1e6*1.66054e-27 # la masse de la GMol\n",
    "eps0 = 8.854187*1e-12  # permittivité électrique du vide\n",
    "\n",
    "\n",
    "r0 = 2.5e-3 # 2.5e-3   # rayon piège Ca+\n",
    "d0 = (4e-3)/2            # longueur piège Ca+\n",
    "Omega = 2.045e6*2*pi # 2.047e6\n",
    "bk = 4 # nombre de barreaux par groupe (2 -> 4-pole , 4 -> 8-pole ...)\n",
    "\n",
    "mkappa = 0.23          # écrantage piège réel GiantMol\n",
    "wzLC = (2*pi*90806.9982303)**2\n",
    "kappa_simion = m_Ca*d0**2*wzLC/(2*C_e)\n",
    "mkappa = 0.23\n",
    "print('%s = %f' % ('$\\kappa_{simion}$',kappa_simion) )\n",
    "\n",
    "zeta = kappa_simion*r0**2/d0**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Urf = 42.5\n",
      "non adiab 0.2898831690338153\n",
      "adiab     0.2804236733945176\n",
      "alpha = 0.1995320237156086\n",
      "qx = 0.39657896212501004\n",
      "ax = 0.0\n",
      "az = 0.0083835626184515\n",
      "f_z = 132401.41324666748\n",
      "f_x = 296405.5403370761\n",
      "f_r = 281231.5366875782\n",
      "f_x non_adia = 286733.20604589424\n"
     ]
    }
   ],
   "source": [
    "# Computation of secular frequencies\n",
    "\n",
    "# set voltages\n",
    "Udc = 2.5 # 2.8628*4   9.014464\n",
    "Urf = 170/4\n",
    "q = ( (m_Ca*r0**2*Omega**2)/( 4*C_e)/Urf )**(-1)\n",
    "print('Urf =',Urf)\n",
    "\n",
    "# compute beta\n",
    "beta_guess = 0.423\n",
    "a = 0\n",
    "for k in range(15):\n",
    "    beta_guess = beta_continue_alamano(a,q,beta_guess)\n",
    "    beta_guess = sqrt(beta_guess)\n",
    "#     print(beta_guess)\n",
    "print('non adiab',beta_guess)\n",
    "print('adiab    ',sqrt(a+q**2/2))\n",
    "\n",
    "# compute angular frequencies\n",
    "omega_z_2 = 2*C_e*(mkappa)*Udc/m_Ca/d0**2\n",
    "# omega_x_2 = 2*(C_e*Urf/m_Ca/Omega/r0**2)**2\n",
    "omega_x_2 = ( beta_guess*Omega/2 )**2\n",
    "omega_r_2 = omega_x_2 - 0.5*omega_z_2\n",
    "\n",
    "# compute Mathieu parameters\n",
    "qx = 4*C_e*Urf/(m_Ca*r0**2*Omega**2)\n",
    "ax = 8*C_e*0/(m_Ca*r0**2*Omega**2)\n",
    "az = 2*omega_z_2/Omega**2\n",
    "\n",
    "print('alpha =',omega_z_2/omega_x_2)\n",
    "print('qx =',qx)\n",
    "print('ax =',ax)\n",
    "print('az =',az)\n",
    "print('f_z =',sqrt(omega_z_2)/2/pi)\n",
    "print('f_x =',sqrt(omega_x_2)/2/pi)\n",
    "print('f_r =',sqrt(omega_r_2)/2/pi)\n",
    "\n",
    "print('f_x non_adia =',sqrt(a+q**2/2)*Omega/2/2/pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extraction de données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename=[]\n",
    "# K:/20220713/tickle_169.9Vpp_2500mV_0_0_100k_400k_000.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sélection des fichiers\n",
    "import tkinter as tk\n",
    "from tkinter import filedialog\n",
    "\n",
    "root = tk.Tk()\n",
    "root.withdraw()\n",
    "\n",
    "file_path = filedialog.askopenfilename(initialdir = '/home/adrian/Documents/Mesures',multiple=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32.5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "130/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> 00 e_130Vpp_1000mV_0_0_050k_350k_000.dat\n",
      "> 01 e_130Vpp_1000mV_0_0_050k_350k_001.dat\n",
      "> 02 e_130Vpp_1000mV_0_0_050k_350k_002.dat\n",
      "> 03 e_150Vpp_1000mV_0_0_050k_350k_000.dat\n",
      "> 04 e_150Vpp_1000mV_0_0_050k_350k_001.dat\n",
      "> 05 e_150Vpp_1000mV_0_0_050k_350k_002.dat\n",
      "> 06 e_150Vpp_1000mV_0_0_050k_350k_003.dat\n",
      "> 07 169_9Vpp_2500mV_0_0_100k_400k_000.dat\n",
      "> 08 e_170Vpp_1000mV_0_0_050k_350k_000.dat\n",
      "> 09 e_170Vpp_1000mV_0_0_050k_350k_001.dat\n",
      "> 10 e_170Vpp_1000mV_0_0_050k_350k_002.dat\n",
      "> 11 e_170Vpp_1000mV_0_0_050k_350k_003.dat\n",
      "> 12 e_170Vpp_1000mV_0_0_050k_350k_004.dat\n",
      "> 13 e_170Vpp_1500mV_0_0_100k_400k_000.dat\n",
      "> 14 e_170Vpp_1500mV_0_0_100k_400k_001.dat\n",
      "> 15 e_170Vpp_2000mV_0_0_100k_400k_000.dat\n",
      "> 16 e_170Vpp_2000mV_0_0_100k_400k_001.dat\n",
      "> 17 e_170Vpp_2000mV_0_0_100k_400k_002.dat\n",
      "> 18 e_170Vpp_2500mV_0_0_100k_400k_000.dat\n",
      "> 19 e_170Vpp_2500mV_0_0_100k_400k_001.dat\n",
      "> 20 e_170Vpp_2500mV_0_0_100k_400k_002.dat\n",
      "> 21 e_170Vpp_2500mV_0_0_100k_400k_003.dat\n",
      "> 22 e_170Vpp_2500mV_0_0_400k_100k_000.dat\n",
      "> 23 e_170Vpp_2500mV_0_0_400k_100k_001.dat\n",
      "> 24 e_170Vpp_2500mV_0_0_400k_100k_002.dat\n"
     ]
    }
   ],
   "source": [
    "for i,j in enumerate(file_path):\n",
    "    print('>',f'{i:02d}',j[-37:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# open the files and save the data\n",
    "# TP is time\n",
    "# PM is fluo\n",
    "# VB is voltage applied to the GBF\n",
    "filename=file_path\n",
    "m=len(filename)\n",
    "n=len(loadtxt('%s' %filename[1],usecols=(0),unpack=True))\n",
    "shape=(m,n)\n",
    "# Temps, PM, Tension Pzt bleu\n",
    "TP = zeros(shape)\n",
    "PM = zeros(shape)\n",
    "Vmod = zeros(shape)\n",
    "for k in range(0,len(filename),1):\n",
    "    TP[:][k],PM[:][k],Vmod[:][k] = loadtxt('%s' %filename[k],usecols=(0,1,4),unpack=True)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "350\n"
     ]
    }
   ],
   "source": [
    "pos_freq = file_path[to_plot].find('mV_')\n",
    "print(file_path[to_plot][pos_freq+12:pos_freq+15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "712"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(214/300*len(freq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D:/giantmol/data/manip_giantmol/20220713/tickle_130Vpp_1000mV_0_0_050k_350k_000.dat\n"
     ]
    }
   ],
   "source": [
    "# chose a file and plot it\n",
    "to_plot = 0\n",
    "print(file_path[to_plot])\n",
    "pos_freq = file_path[to_plot].find('mV_')\n",
    "freq_start = int(file_path[to_plot][pos_freq+7:pos_freq+10])\n",
    "freq_end   = int(file_path[to_plot][pos_freq+12:pos_freq+15])\n",
    "#pos_freq = file_path[to_plot].find('mV_')\n",
    "#freq_start = int(file_path[to_plot][pos_freq+3:pos_freq+4])\n",
    "#freq_end   = int(file_path[to_plot][pos_freq+5:pos_freq+8])\n",
    "freq       = (Vmod[:][to_plot]+5)*( freq_end - freq_start )/( Vmod[to_plot][-1]-Vmod[to_plot][0] ) + freq_start\n",
    "# freq = linspace(freq_start,freq_end,len(TP[:][to_plot]))\n",
    "# print(freq)\n",
    "#pos_min = find_peaks(PM[:][to_plot],prominence=(250,None))[0] # max(PM[:][to_plot])/2,distance=50\n",
    "pos_min = argrelextrema(PM[:][to_plot],less,order=50)\n",
    "\n",
    "figure('Plot tickle').clf()\n",
    "\n",
    "plot(freq,PM[to_plot],label=f'{file_path[to_plot][-35:-4]},to_plot={to_plot}')\n",
    "plot(freq[pos_min],PM[to_plot][pos_min],'P') # [800]*len(freq[pos_min])\n",
    "for i,j in enumerate(pos_min[0]):\n",
    "    text(freq[j],PM[to_plot][j]*0.975,f'{freq[j]:.1f}',fontsize=12)\n",
    "    \n",
    "# alamano    280\n",
    "#zzz = 180\n",
    "#plot(freq[int(zzz/300*len(freq))],PM[to_plot][int(zzz/300*len(freq))],marker='P',color='xkcd:rouge')\n",
    "#text(freq[int(zzz/300*len(freq))]-10,PM[to_plot][int(zzz/300*len(freq))]*0.975,f'{freq[int(zzz/300*len(freq))]:.1f}',fontsize=12)\n",
    "\n",
    "xlabel('Tickle frequency [kHz]')\n",
    "ylabel('Fluorescence [cnt/250ms]')\n",
    "grid(b=True, which='major', color='0.2', linestyle='-')\n",
    "grid(b=True, which='minor', color='0.7', linestyle='--')\n",
    "legend()\n",
    "plt.minorticks_on()\n",
    "plt.tight_layout()\n",
    "\n",
    "savefig(f'{file_path[to_plot][-35:-4]}',dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bad start\n",
    "# 0 1\n",
    "# bad resonance\n",
    "# 2 3     4 5 6 7 24 bad also\n",
    "\n",
    "# exploitable\n",
    "# 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22? 23?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "argrelextrema(PM_170_2000,less,order=50)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's compare\n",
    "# 8 9 10           tickle_170Vpp_2000mV_0_0_100k_400k\n",
    "PM_170_2000 = mean(PM[:][15:18],axis=0)\n",
    "to_plot = 15\n",
    "pos_freq = file_path[to_plot].find('0_0_')\n",
    "freq_start = int(file_path[to_plot][pos_freq+4:pos_freq+7])\n",
    "freq_end   = int(file_path[to_plot][pos_freq+9:pos_freq+12])\n",
    "freq_170_2000 = (Vmod[:][to_plot]+5)*( freq_end - freq_start )/( Vmod[to_plot][-1]-Vmod[to_plot][0] ) + freq_start\n",
    "pos_min_170_2000 = argrelextrema(PM_170_2000,less,order=80)[0]\n",
    "# 13 14 15 16 17   tickle_170Vpp_1000mV_0_0_050k_350k\n",
    "PM_170_1000 = mean(PM[:][8:11],axis=0)\n",
    "to_plot = 8\n",
    "pos_freq = file_path[to_plot].find('0_0_')\n",
    "freq_start = int(file_path[to_plot][pos_freq+4:pos_freq+7])\n",
    "freq_end   = int(file_path[to_plot][pos_freq+9:pos_freq+12])\n",
    "freq_170_1000 = (Vmod[:][to_plot]+5)*( freq_end - freq_start )/( Vmod[to_plot][-1]-Vmod[to_plot][0] ) + freq_start\n",
    "pos_min_170_1000 = argrelextrema(PM_170_1000,less,order=80)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [],
   "source": [
    "figure('Plot tickle 170_2000').clf()\n",
    "\n",
    "plot(freq_170_2000,PM_170_2000,label=f'to_plot={to_plot} to {to_plot+3}')\n",
    "plot(freq_170_2000[pos_min_170_2000],PM_170_2000[pos_min_170_2000],'P')\n",
    "\n",
    "for i,j in enumerate(pos_min_170_2000):\n",
    "    text(freq_170_2000[j],PM_170_2000[j]*0.975,f'{freq_170_2000[j]:.1f}',fontsize=12)\n",
    "# plot(freq_170_1000,PM[:][10])\n",
    "# plot(freq[pos_min],PM[to_plot][pos_min],'P') # [800]*len(freq[pos_min])\n",
    "# plot(freq[1000-2:-1],PM[1],'r')\n",
    "xlabel('Tickle frequency [kHz]')\n",
    "ylabel('Fluorescence [cnt/60ms]')\n",
    "grid()\n",
    "legend()\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[136.97790839 199.48501404 269.54660143 324.85700358 371.74246506]\n"
     ]
    }
   ],
   "source": [
    "# plot freq of peaks\n",
    "print(freq_170_1000[pos_min_170_2000])\n",
    "\n",
    "# compare with expecteed values\n",
    "# for Urf = 42.43 V, Udc = 2 V\n",
    "# f_z = 118423.42413463586\n",
    "# f_x = 295882.3513634161\n",
    "# f_r = 283785.679970745"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [],
   "source": [
    "figure('Plot tickle 170_1000').clf()\n",
    "\n",
    "plot(freq_170_1000,PM_170_1000,label=f'to_plot={to_plot} to {to_plot+4}')\n",
    "plot(freq_170_1000[pos_min_170_1000],PM_170_1000[pos_min_170_1000],'P')\n",
    "\n",
    "for i,j in enumerate(pos_min_170_1000):\n",
    "    text(freq_170_1000[j],PM_170_1000[j]*0.975,f'{freq_170_1000[j]:.1f}',fontsize=12)\n",
    "# plot(freq_170_1000,PM[:][10])\n",
    "# plot(freq[pos_min],PM[to_plot][pos_min],'P') # [800]*len(freq[pos_min])\n",
    "# plot(freq[1000-2:-1],PM[1],'r')\n",
    "xlabel('Tickle frequency [kHz]')\n",
    "ylabel('Fluorescence [cnt/60ms]')\n",
    "grid()\n",
    "legend()\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot freq of peaks\n",
    "print(freq_170_1000[pos_min_170_1000])\n",
    "\n",
    "# compare with expecteed values\n",
    "# for Urf = 42.43 V, Udc = 1 V\n",
    "# f_z = 83738.00625693168\n",
    "# f_x = 295882.3513634161\n",
    "# f_r = 289897.1179615297"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    }
   ],
   "source": [
    "# data from 220720\n",
    "# let's compare\n",
    "# 8 9 10           tickle_170Vpp_2000mV_0_0_100k_400k\n",
    "PM_mean = mean(PM[:][5:6],axis=0)\n",
    "freq = linspace(000,250,len(TP[:][3]))\n",
    "pos_min = argrelextrema(PM_mean,less,order=80)[0]\n",
    "\n",
    "figure('Plot tickle 110Vpp').clf()\n",
    "\n",
    "plot(freq,PM_mean,color='xkcd:bright orange',label='tickle_003')\n",
    "plot(freq[pos_min],PM_mean[pos_min],'P',color='xkcd:azul')\n",
    "to_plot = 3\n",
    "plot(freq,PM[:][to_plot],color='k',lw=0.6,ls=':',label='tickle_002')\n",
    "\n",
    "for i,j in enumerate(pos_min):\n",
    "    text(freq[j]+0.8,PM_mean[j]-0.005,f'{freq[j]:.1f}',fontsize=12,color='xkcd:cherry red')\n",
    "# ajouts à la mano\n",
    "plot(187.17,5120,'X',color='xkcd:olive brown')\n",
    "text(187.17+0.8,5120-0.005,f'{187.17:.1f}',fontsize=12,color='xkcd:olive brown')\n",
    "\n",
    "plot(111.6,4655,'X',color='xkcd:olive brown')\n",
    "text(111.6+0.8,4655-0.005,f'{111.6:.1f}',fontsize=12,color='xkcd:olive brown')\n",
    "    \n",
    "title('Tickle 19 juillet 22')\n",
    "xlabel('Tickle frequency [kHz]')\n",
    "ylabel('Fluorescence [cnt/60ms]')\n",
    "legend()\n",
    "grid()\n",
    "plt.tight_layout()\n",
    "\n",
    "savefig('tickle_result_002_003.eps',dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    }
   ],
   "source": [
    "# data from 220720\n",
    "# let's compare\n",
    "PM_mean = mean(PM[:][3:4],axis=0)\n",
    "freq = linspace(000,200,len(TP[:][3]))\n",
    "pos_min = argrelextrema(PM_mean,less,order=80)[0]\n",
    "\n",
    "figure('Plot tickle 110Vpp').clf()\n",
    "\n",
    "plot(freq,PM_mean,color='xkcd:bright orange',label='tickle_003')\n",
    "plot(freq[pos_min],PM_mean[pos_min],'P',color='xkcd:azul')\n",
    "to_plot = 2\n",
    "plot(freq,PM[:][to_plot],color='k',lw=0.6,ls=':',label='tickle_002')\n",
    "\n",
    "for i,j in enumerate(pos_min):\n",
    "    text(freq[j]+0.8,PM_mean[j]-0.005,f'{freq[j]:.1f}',fontsize=12,color='xkcd:cherry red')\n",
    "# ajouts à la mano\n",
    "plot(187.17,5120,'X',color='xkcd:olive brown')\n",
    "text(187.17+0.8,5120-0.005,f'{187.17:.1f}',fontsize=12,color='xkcd:olive brown')\n",
    "\n",
    "plot(111.6,4655,'X',color='xkcd:olive brown')\n",
    "text(111.6+0.8,4655-0.005,f'{111.6:.1f}',fontsize=12,color='xkcd:olive brown')\n",
    "    \n",
    "title('Tickle 19 juillet 22')\n",
    "xlabel('Tickle frequency [kHz]')\n",
    "ylabel('Fluorescence [cnt/60ms]')\n",
    "legend()\n",
    "grid()\n",
    "plt.tight_layout()\n",
    "\n",
    "savefig('tickle_result_002_003.eps',dpi=300)"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}