sorting_binning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The radiation source ELBE (**E**lectron **L**inac for beams with high **B**rilliance and low **E**mittance) at the Helmholtz Centre Dresden Rossendorf (HZDR) can produce several kinds of secondary radiations. THz radiation is one of them and can be used with a typical pulse frequency of 100 kHz as a stimulation source for elementary low-energy degrees of freedom in matter. It was used in the \\\"Phase-resolved Higgs response in superconducting cuprates\\\" publication (DOI: [10.1038/s41467-020-15613-1](https://doi.org/10.1038/s41467-020-15613-1)). The raw data for this publication can be accessed on RODARE (DOI: [10.14278/rodare.1289](https://doi.org/10.14278/rodare.1289)) and will be used to reproduce the figures from the publication\n",
    "\n",
    "This Jupyter notebook enables the user to handle the raw data from an TELBE THz experiment. To sample the whole THz wave the laser path length is modified by moving specific mirrors. The raw data contains for each mirror position a binary file storing the signal spectra and a folder with gray scaled tiff files storing the jitter timing.\n",
    "\n",
    "The notebook contains 2 parts. For new data start with **1. Sorting and binning the raw data**. If you have it done already in a previous session continue with section **2. Plotting results** in the middle of this notebook.\n",
    "\n",
    "## 1. Sorting and binning of raw data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1. Import Packages\n",
    "\n",
    "Common libraries like numpy and scipy are used to handle the data matrices and to filter the signal data. Multiprocessing is used to use multiple cores for the parallelized parts and the number of cores can be individual adjusted. Matplotlib is used to present the results visually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install numpy\n",
    "%pip install pillow\n",
    "%pip install scipy\n",
    "%pip install matplotlib\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "from scipy.signal import butter, lfilter\n",
    "import os, sys, time, requests, re, json, fnmatch, shutil\n",
    "from zipfile import BadZipFile, ZipFile\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MultipleLocator\n",
    "from multiprocessing import Pool\n",
    "from functools import partial\n",
    "from urllib import request\n",
    "from urllib.parse import urlparse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2. Load class containing functions to sort and bin the raw data \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "class sorting_binning:\n",
    "    \"\"\"Class to manage the sorting and binning process for TELBE raw data.\"\"\"\n",
    "    \n",
    "    def __init__(self, folder_in, params):\n",
    "        if not os.path.isdir(folder_in):\n",
    "            print(f'Folder {folder_in} does not exist!')\n",
    "            sys.exit(1)\n",
    "\n",
    "        if folder_in[-1] == '/':\n",
    "            folder_in = folder_in[:-1]\n",
    "\n",
    "        \"\"\"Set variables/constants\"\"\"\n",
    "        self.rep = params['rep'] # repetition rate of TELBE in Hz\n",
    "        self.t_exp = params['t_exp'] # time os single step measurement\n",
    "        self.N_sample = params['N_sample'] # number of points measured by ADC for single event - it should be even \n",
    "        self.offset = params['offset'] # offset between CCD and ADC\n",
    "        self.pixel_to_ps = params['pixel_to_ps'] # conversion from pixel to ps\n",
    "        self.Stage_zero = params['Stage_zero'] # position in mm of zero time\n",
    "        self.mm_to_ps = 1/299792458*2*10**9\n",
    "        self.searchstring = \"[0-9]{2}.[0-9]{2}.[0-9]{4}_[0-9]{4}_[0-9]{2}\"\n",
    "        self.set_savesort()\n",
    "        self.set_cores()\n",
    "        self.set_res(0.02)  # time resolution for binned file\n",
    "\n",
    "        self.folder_in = folder_in\n",
    "        top_folder, folder_name = os.path.split(self.folder_in)\n",
    "\n",
    "        date_str = re.search(self.searchstring, folder_name)[0]\n",
    "        date = datetime.strptime(date_str, '%d.%m.%Y_%H%M_%S')\n",
    "        folder = f'{date:%Y-%B_datasorting}'\n",
    "        datasorting_folder = os.path.join(str(date.year), folder)\n",
    "\n",
    "        folder = f'{date:%Y-%m-%d}'\n",
    "        self.sorted_folder = os.path.join(datasorting_folder, folder)\n",
    "        self.binned_folder = os.path.join(self.sorted_folder, 'binned')\n",
    "        os.makedirs(self.binned_folder, exist_ok=True)\n",
    "\n",
    "        self.file_out_sorted = os.path.join(self.sorted_folder, folder_name + '_sorted.dat')\n",
    "        self.file_out_binned = os.path.join(self.binned_folder, folder_name + '_sorted_binned.dat')\n",
    "\n",
    "\n",
    "    def set_savesort(self, savesort=False):\n",
    "        self.savesort = savesort\n",
    "    \n",
    "    def set_cores(self, cores=1):\n",
    "        self.cores = cores\n",
    "\n",
    "    def set_recalc(self, recalc=False):\n",
    "        self.recalc = recalc\n",
    "    \n",
    "    def set_res(self, res=0.02):\n",
    "        self.res = res\n",
    "        \n",
    "    def _jitter(self, SP, BG, graph):\n",
    "        \"\"\"Correct the timing of each electron pulse.\"\"\"\n",
    "        low_cut=0.00001\n",
    "        high_cut=0.04\n",
    "        b, a = butter(3, [low_cut, high_cut], btype='band')\n",
    "        bg=np.genfromtxt(BG,max_rows=1)\n",
    "        arrival_time=np.array([])\n",
    "        images = os.listdir(SP)\n",
    "        images.sort()\n",
    "        for i in images:\n",
    "            im = Image.open(os.path.join(SP,i))\n",
    "            SDEOS = np.array(im, dtype=np.uint16)\n",
    "            if SDEOS[0,0] > 2**15 - 1:\n",
    "                SDEOS = SDEOS - 2**15\n",
    "            arrival_time = np.concatenate([arrival_time,[np.argmax(lfilter(b, a, SDEOS[j,:]-bg))\\\n",
    "                                                         for j in range(0, SDEOS.shape[0])]])\n",
    "        if graph:\n",
    "            filtered = lfilter(b, a, SDEOS[1,:]-bg)\n",
    "            x_fil = range(len(filtered))\n",
    "            raw = SDEOS[1,:]-bg\n",
    "            x_raw = range(len(raw))\n",
    "            jitter_data = np.array([x_raw,raw,x_fil,filtered])\n",
    "            with open('tmp.txt','w') as jitter_dump:\n",
    "                np.savetxt(jitter_dump, jitter_data)\n",
    "            fig = plt.figure()\n",
    "            ax = fig.add_subplot(111)\n",
    "            ax.plot(x_raw,raw,label=\"raw data\")\n",
    "            ax.plot(x_fil,filtered,label=\"butter fit\")\n",
    "            fig.savefig('jitter'+os.path.basename(SP)+'.png')\n",
    "            print('\"Check \"jitter'+os.path.basename(SP)+'.png\" if fit is good.')\n",
    "        return arrival_time  \n",
    "\n",
    "\n",
    "    def _signal(self, ADC):\n",
    "        \"\"\"Integrate the Signal of each electron pulse.\"\"\"\n",
    "        N_shots=int(self.rep/self.t_exp) # pulses of TELBE per single step\n",
    "        ADC_Width=int(self.N_sample/2) # half of the trace is for signal, second half - for background\n",
    "        t1=np.fromfile(ADC,dtype='>f')\n",
    "        Signal=np.zeros(N_shots)\n",
    "        for i in range(0,N_shots):\n",
    "            Signal[i]=np.sum(t1[(self.N_sample*i):(self.N_sample*i+ADC_Width)])-\\\n",
    "                np.sum(t1[(self.N_sample*i+ADC_Width):(self.N_sample*i+self.N_sample)])\n",
    "        return Signal    \n",
    "\n",
    "\n",
    "    def _bin_mean(self, data, digitized, bin_n):\n",
    "        \"\"\"Calculate the mean of each bin.\"\"\"\n",
    "        data_bin = data[digitized == bin_n]\n",
    "        if len(data_bin) == 0:\n",
    "            return np.nan\n",
    "        else:\n",
    "            return np.mean(data_bin)\n",
    "\n",
    "    def binning(self):\n",
    "        \"\"\"Binning of the sorted data.\"\"\"\n",
    "        self.start = time.time()\n",
    "        print(f'Binned file:\\t{self.file_out_binned}')\n",
    "        if os.path.isfile(self.file_out_binned) and not self.recalc:\n",
    "            print('Load from file')\n",
    "            self.binned_data = np.loadtxt(self.file_out_binned)\n",
    "            print(f\"Time loading from file: {time.time()-self.start:.2f} s\")\n",
    "        else:\n",
    "            print('Start binning')\n",
    "            sorted_min = int(np.floor(min(self.sorted_data[:,0])*self.pixel_to_ps/self.res))\n",
    "            sorted_max = int(np.ceil(max(self.sorted_data[:,0])*self.pixel_to_ps/self.res))\n",
    "            num = int(np.floor(np.abs(sorted_max - sorted_min)))\n",
    "            space_bin = np.linspace(sorted_min, sorted_min + num, num=num + 1)*self.res\n",
    "            digitized=np.digitize(self.sorted_data[:,0]*self.pixel_to_ps,space_bin)\n",
    "            print(f\"Time elapsed after preparing binning: {time.time()-self.start:.2f} s\")\n",
    "            with Pool(self.cores) as processPool:\n",
    "                mean_bin = processPool.map(partial(self._bin_mean, self.sorted_data[:,1], digitized),\\\n",
    "                                           range(0, len(space_bin)))\n",
    "            self.binned_data = np.vstack((space_bin, mean_bin)).T\n",
    "            np.savetxt(self.file_out_binned, self.binned_data, fmt='%0.{}f %0.8f'.format(int(np.ceil(np.log10(1/self.res)))))\n",
    "            print(f\"Time elapsed after multiprocessing binning: {time.time()-self.start:.2f} s\")\n",
    "            print('Binning done')\n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(111)\n",
    "        ax.plot(self.binned_data[:,0], self.binned_data[:,1])\n",
    "        ax.set_xlabel(r'time / ps')\n",
    "        ax.set_ylabel(r'signal / a.u.')\n",
    "        #fig.savefig('binning.png')\n",
    "\n",
    "\n",
    "    def _sorting_one_position(self, subfolder, subfiles, BG, first_folder):\n",
    "        \"\"\"Calculate the jitter and signal data for each mirror position.\"\"\"\n",
    "        stage_pos = re.findall('_([0-9.]*)mm', subfolder)[-1]\n",
    "        EOS=fnmatch.filter(subfiles, '*'+'Experiment'+'*'+stage_pos+'*')[0]\n",
    "        jitter_data = (self._jitter(subfolder, BG, first_folder == subfolder)\\\n",
    "                       +(float(stage_pos)-self.Stage_zero)*self.mm_to_ps/self.pixel_to_ps).astype(int)\n",
    "        signal_data = np.roll(self._signal(EOS),self.offset)\n",
    "        if jitter_data.shape[0] != signal_data.shape[0]:\n",
    "            print(f\"Shape of jitter data ({jitter_data.shape}) and signal data ({signal_data.shape}) is not consistent.\\\n",
    "                  Adjust parameter 'rep'\")\n",
    "        return np.vstack((jitter_data, signal_data)).T\n",
    "    \n",
    "        \n",
    "    def sorting(self, position=None):\n",
    "        \"\"\"Sort all data points.\"\"\"\n",
    "        self.position = position\n",
    "        self.start = time.time()\n",
    "        print(f'Data folder: {self.folder_in}')\n",
    "        if self.savesort:\n",
    "            print(f'Sorted file:\\t{self.file_out_sorted}')\n",
    "        else:\n",
    "            print('Sorted file is not stored')\n",
    "\n",
    "        if os.path.isfile(self.file_out_sorted) and position is None and not self.recalc:\n",
    "            print('Load from file')\n",
    "            self.sorted_data = np.loadtxt(self.file_out_sorted)\n",
    "            print(f\"Time elapsed after loading sorted file: {time.time()-self.start:.2f} s\")\n",
    "            fig = plt.figure()\n",
    "            ax = fig.add_subplot(111)\n",
    "            ax.scatter(self.sorted_data[:,0], self.sorted_data[:,1], s=1)\n",
    "            ax.set_xlabel(r'pixel')\n",
    "            ax.set_ylabel(r'signal / a.u.')\n",
    "            ax.set_title(r'Sorted data');\n",
    "            print('Loading done')\n",
    "        else:\n",
    "            print('Start sorting')\n",
    "            subfolders = [f.path for f in os.scandir(self.folder_in) if f.is_dir()]\n",
    "            subfolders.sort()\n",
    "            if position is not None:\n",
    "                self.position=fnmatch.filter(subfolders, '*'+position+'*mm*')\n",
    "                if len(self.position) > 1:\n",
    "                    print(f\"found match for multiple positions. First one choosen:\\n{self.position}\")\n",
    "                elif len(self.position) == 0:\n",
    "                    print(\"No match found\")\n",
    "                    return 1\n",
    "                else:\n",
    "                    print(f\"Sorting choosen for {self.position}\")\n",
    "                    subfolders = self.position\n",
    "            subfiles = [f.path for f in os.scandir(self.folder_in) if f.is_file()]\n",
    "            background = fnmatch.filter(subfiles, '*'+'_BG_'+'*')[0]\n",
    "            if not background:\n",
    "                print('Background file not found!')    #count_of_steps = len(subfolders)\n",
    "\n",
    "            fig, axs = plt.subplots(ncols=2,figsize=(10, 4))\n",
    "            print(f\"Time elapsed for preparetion: {time.time()-self.start:.2f} s\")\n",
    "            with Pool(self.cores) as processPool:\n",
    "                self.sorted_data = np.concatenate((processPool.map(\n",
    "                    partial(self._sorting_one_position, subfiles=subfiles, BG=background,\\\n",
    "                            first_folder= subfolders[0]), subfolders)))\n",
    "            with open('tmp.txt','r') as jitter_dump:\n",
    "                self.jitter_data = np.loadtxt(jitter_dump)\n",
    "\n",
    "            axs[0].plot(self.jitter_data[0],self.jitter_data[1],label=\"raw data\")\n",
    "            axs[0].plot(self.jitter_data[2],self.jitter_data[3],label=\"butter fit\")\n",
    "            axs[0].set_xlabel(r'time / pixel')\n",
    "            axs[0].set_ylabel(r'signal / a.u.')\n",
    "            axs[0].set_title(r'Determine jitter time');\n",
    "            leg = axs[0].legend(loc='upper right', shadow=True)\n",
    "\n",
    "            axs[1].scatter(self.sorted_data[:,0], self.sorted_data[:,1], s=1)\n",
    "            axs[1].set_xlabel(r'pixel')\n",
    "            axs[1].set_ylabel(r'signal / a.u.')\n",
    "            axs[1].set_title(r'Sorted data');\n",
    "            #fig.savefig('sorted.png')\n",
    "            print(f\"Time elapsed after multiprocessing sorting: {time.time()-self.start:.2f} s\")\n",
    "            if self.savesort and position is None:\n",
    "                with open(self.file_out_sorted,'wb') as fff:\n",
    "                    np.savetxt(fff, self.sorted_data) \n",
    "                print(f\"Time elapsed after writing sorted file: {time.time()-self.start:.2f} s\")\n",
    "            print('Sorting done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3. Select and download data set\n",
    "\n",
    "1. Select a data set from the RODARE record (https://rodare.hzdr.de/record/1289). It contains all raw data from the Nature publication: https://doi.org/10.1038/s41467-020-15613-1. As an starting example choose one of the following file numbers, which where used to generate each individual figure from the publication:\n",
    "   * Fig. 1(a): 053\n",
    "   * Fig. 1(b): 038\n",
    "   * Fig. 1(e): 033, 038, 045, 051, 053\n",
    "\n",
    "\n",
    "2. copy link from the download button in an RODARE record (www.rodare.hzdr.de/record/1289)\n",
    "3. save link as url variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading selected file.\n",
      "Unpacking '038_0p7THz_LSCO_2mmZnTe_31K_13.06.2018_0535_02.zip' to '038_0p7THz_LSCO_2mmZnTe_31K_13.06.2018_0535_02'.\n",
      "Unpacking done.\n"
     ]
    }
   ],
   "source": [
    "url = \"https://rodare.hzdr.de/record/1289/files/038_0p7THz_LSCO_2mmZnTe_31K_13.06.2018_0535_02.zip?download=1\"\n",
    "\n",
    "parse_object = urlparse(url)\n",
    "filename = parse_object.path.split(\"/\")[-1]\n",
    "if not os.path.isfile(filename):\n",
    "    print(\"Downloading selected file.\")\n",
    "    request.urlretrieve(url, filename)\n",
    "else:\n",
    "    print(f\"File {filename} exists already\")\n",
    "folder_in = os.path.splitext(filename)[0]\n",
    "assert not os.path.isfile(\"raw_data\"), \"Remove or rename 'raw_data' file before rerun.\"\n",
    "if not os.path.isdir(folder_in):\n",
    "    try:\n",
    "        print(f\"Unpacking '{filename}' to '{folder_in}'.\")\n",
    "        with ZipFile(filename) as z:\n",
    "            z.extractall(path=\"raw_data\")\n",
    "            # removing abs path\n",
    "            path_list = [x[0] for x in os.walk('raw_data')]\n",
    "            for path in path_list:\n",
    "                if folder_in in path:\n",
    "                    shutil.move(path, os.path.basename(path))\n",
    "                    break\n",
    "            shutil.rmtree('raw_data')\n",
    "            print(\"Unpacking done.\")\n",
    "    except (FileNotFoundError, BadZipFile):\n",
    "        print(\"Invalid zip file.\")\n",
    "        sys.exit(1)\n",
    "else:\n",
    "    print(\"File was already unpacked.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4. Set parameters and initialize class\n",
    "\n",
    "The chooses parameters in params are set for the above mentioned RODARE record. A description for the parameters can be found in the class definition under section 1.2. Set *set_cores* to the number of availaible cores and set *set_savesort* to *False* if you don't want to save the intermediate sorted file (~350 MB, ~30 s to write on disk). With *set_res* you can change the size of the bins for the binning function (default is 0.02 ps). If you don't want to read from file set *set_recalc* to *True*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    \"rep\": 100000,\n",
    "    \"t_exp\": 1,\n",
    "    \"N_sample\": 96,\n",
    "    \"offset\": 0,\n",
    "    \"pixel_to_ps\": 0.0115,\n",
    "    \"Stage_zero\": 0\n",
    "}\n",
    "sortbin = sorting_binning(folder_in, params)\n",
    "sortbin.set_cores(2)\n",
    "sortbin.set_savesort(True)\n",
    "#sortbin.set_res(0.02)\n",
    "sortbin.set_recalc(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5. Run sorting raw data, choose one option\n",
    "\n",
    "The main part of the sorting process is to correct the timing of each signal pulse. For each pulse the timing jitter is determined and assigned. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide_input": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data folder: 038_0p7THz_LSCO_2mmZnTe_31K_13.06.2018_0535_02\n",
      "Sorted file:\t2018/2018-June_datasorting/2018-June_datasorting/038_0p7THz_LSCO_2mmZnTe_31K_13.06.2018_0535_02_sorted.dat\n",
      "Start sorting\n",
      "Time elapsed for preparetion: 0.05 s\n",
      "\"Check \"jitter038_0p7THz_LSCO_2mmZnTe_31K_SD_101523Hz_51.10mm13.06.2018_0535_02.png\" if fit is good.\n",
      "Time elapsed after multiprocessing sorting: 323.34 s\n",
      "Time elapsed after writing sorted file: 347.55 s\n",
      "Sorting done\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\"\"\"Run single position by providing the mirror position in mm, written in the filename\"\"\"\n",
    "#sortbin.sorting(position='51.1')\n",
    "\n",
    "\"\"\"Run all position\"\"\"\n",
    "sortbin.sorting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6. Run binning data\n",
    "\n",
    "After all data point have their correct time (x-value), a data reduction is done by the binning process. The mean value of all signal values in one bin is taken as the representative value for this bin. Now the wave is clearly visible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binned file:\t2018/2018-June_datasorting/2018-June_datasorting/binned/038_0p7THz_LSCO_2mmZnTe_31K_13.06.2018_0535_02_sorted_binned.dat\n",
      "Start binning\n",
      "Time elapsed after preparing binning: 2.04 s\n",
      "Time elapsed after multiprocessing binning: 47.49 s\n",
      "Binning done\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "sortbin.binning()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Plotting results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Load class containing function for plotting TELBE data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "class plot_telbe:\n",
    "    \"\"\"Command Line Interface (CLI) class managing the user interaction.\"\"\"\n",
    "\n",
    "    def __init__(self, filelist):\n",
    "        \"\"\"Parser initialization.\"\"\"\n",
    "\n",
    "        self.filelist = []\n",
    "        self.filenames = []\n",
    "        for binned_file in filelist:\n",
    "            if not os.path.isfile(binned_file):\n",
    "                print(f'File {binned_file} does not exists!')\n",
    "            else:\n",
    "                self.filelist.append(binned_file)\n",
    "                self.filenames.append(os.path.basename(binned_file))\n",
    "        self.load_data()\n",
    "                \n",
    "\n",
    "    def cut_nan(self, data):\n",
    "        \"\"\"Cut off data points from both sides until all nan values are gone\"\"\"\n",
    "        nan_array = np.where(np.isnan(data[:int(data.shape[0]/2),1:]))[0]\n",
    "        if nan_array.shape[0] > 0: \n",
    "            lower_bound = nan_array.max() + 1\n",
    "        else:\n",
    "            lower_bound = 0\n",
    "        nan_array = np.where(np.isnan(data[int(data.shape[0]/2):,1:]))[0]\n",
    "        if nan_array.shape[0] > 0: \n",
    "            upper_bound = nan_array.min() - data[int(data.shape[0]/2):].shape[0]\n",
    "        else:\n",
    "            upper_bound = None\n",
    "        return data[lower_bound:upper_bound]\n",
    "\n",
    "\n",
    "    def _get_fft_data(self):\n",
    "        \"\"\"Generate fft data from all loops\"\"\"\n",
    "\n",
    "        dt = np.round(self.data[10,0]-self.data[9,0],6)\n",
    "        self.fft_data = np.empty([int(self.data.shape[0]/2)-1,self.data.shape[1]])\n",
    "        for loop in range(self.data.shape[1]-1):\n",
    "            x = self.data[:,0]\n",
    "            yf = np.fft.fft(self.data[:,loop+1])\n",
    "            freq = np.fft.fftfreq(x.shape[-1], d=dt)\n",
    "            #### one side\n",
    "            self.fft_data[:,loop+1] = np.abs(yf[0:int(len(x)/2-1)])\n",
    "            self.fft_data[:,0] = np.abs(freq[0:int(len(x)/2-1)])\n",
    "\n",
    "\n",
    "    def get_data_mean(self, data):\n",
    "        \"\"\"Get mean value over all loops\"\"\"\n",
    "        if data.shape[1] == 2:\n",
    "            return data\n",
    "\n",
    "        mean = np.nanmean(data[:,1:], axis=1)\n",
    "        return np.concatenate((data[:,0][:,None], mean[:,None]),axis=1)\n",
    "\n",
    "\n",
    "    def load_data(self):\n",
    "        \"\"\"Load data of all files in the list\"\"\"\n",
    "        data_list = []\n",
    "        t_range = [[],[]]\n",
    "        res = None\n",
    "        for filepath in self.filelist[:]:\n",
    "            data_list.append(self._load_file(filepath))\n",
    "            if res is None:\n",
    "                res = np.round(data_list[-1][10,0] - data_list[-1][9,0],5)\n",
    "            else:\n",
    "                res_new = np.round(data_list[-1][10,0] - data_list[-1][9,0],5)\n",
    "                assert res == res_new , \"binned files in list, don't have same time-resolution\\\n",
    "                and can't be plotted together\"\n",
    "            t_range[0].append(data_list[-1][0,0])\n",
    "            t_range[1].append(data_list[-1][-1,0])\n",
    "        \n",
    "        data_array = np.zeros([int(np.round(np.abs(np.max(t_range[1]) - np.min(t_range[0]))/res) + 1),\\\n",
    "                               len(data_list) + 1])\n",
    "        data_array[:] = np.nan\n",
    "        pixel = np.linspace(int(np.round(np.min(t_range[0])/res)), int(np.round(np.max(t_range[1])/res)), data_array.shape[0]).astype(int)\n",
    "        data_array[:,0] = list(pixel * res)\n",
    "        pixel = list(pixel)\n",
    "        for idx, data in enumerate(data_list):\n",
    "            if np.round(np.sum(data[1:,0] - data[:-1,0] - res),3) != 0:\n",
    "                print(f\"{self.filelist[idx]} is not equally spaced or some values are missing\")\n",
    "            start = np.where(np.isclose(pixel, data[0,0] / res, atol=0.4))[0][0]\n",
    "            data_array[start:start + data.shape[0],idx+1] = data[:,1]\n",
    "\n",
    "        self.data = self.cut_nan(data_array)\n",
    "        self._get_fft_data()\n",
    "\n",
    "\n",
    "    def _load_file(self, binned_filename):\n",
    "        \"\"\"Load data after checking '.' or ',' is used.\"\"\"\n",
    "        with open(binned_filename) as f:\n",
    "            line = f.readline()\n",
    "        if line.find(',') > 0:\n",
    "            data_str = np.loadtxt(binned_filename,str)\n",
    "            data = np.empty([data_str.shape[0], data_str.shape[1]])\n",
    "            for i in range(data.shape[0]):\n",
    "                for j in range(data.shape[1]):\n",
    "                    data[i,j] = float(data_str[i,j].replace(',','.'))\n",
    "        else:\n",
    "            data = np.loadtxt(binned_filename)\n",
    "        data[:,0] = np.round(data[:,0],5)\n",
    "        return data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Load data by choosing one option\n",
    "\n",
    "If you have want to load from file or want to plot several binned data files together, choose the first option and comment out the second option. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "\"\"\"Specify a list of binned files\"\"\"\n",
    "filelist = ['2018/2018-June_datasorting/2018-06-13/binned/033_0p7THz_LSCO_2mmZnTe_15p7K_13.06.2018_0437_42_sorted_binned.dat',\n",
    "            '2018/2018-June_datasorting/2018-06-13/binned/038_0p7THz_LSCO_2mmZnTe_31K_13.06.2018_0535_02_sorted_binned.dat',\n",
    "            '2018/2018-June_datasorting/2018-06-13/binned/053_0p7THz_LSCO_2mmZnTe_100K_13.06.2018_0849_21_sorted_binned.dat']\n",
    "\n",
    "\"\"\"or take data from previous class as a list.\"\"\"\n",
    "filelist = [sortbin.file_out_binned]\n",
    "\n",
    "tplot = plot_telbe(filelist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Direct plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hide_input": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"Choose one of the next lines: \n",
    "1. \"inline\" for normal/static plot\n",
    "2. \"notebook\" for interactiv plot\n",
    "\"\"\"\n",
    "%matplotlib inline\n",
    "#%matplotlib notebook\n",
    "\n",
    "data_mean = tplot.get_data_mean(tplot.data)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for loop in range(int(tplot.data.shape[1]-1)):\n",
    "    if tplot.data.shape[1] == 2:\n",
    "        ax.plot(tplot.data[:,0], tplot.data[:,loop+1])\n",
    "    else:\n",
    "        ax.plot(tplot.data[:,0], tplot.data[:,loop+1], label=\"file \"+str(tplot.filenames[loop][:3]))\n",
    "\n",
    "if tplot.data.shape[1] > 2:\n",
    "#    ax.plot(data_mean[:,0], data_mean[:,1], label=\"mean value of all loops\")\n",
    "    leg = ax.legend(loc='lower left', shadow=True)\n",
    "\n",
    "xlim = np.array([np.min(tplot.data[:,0]), np.max(tplot.data[:,0])])\n",
    "ax.set_xlim(xlim[0]+5, xlim[1]-5)\n",
    "ax.ticklabel_format(axis='y', style='sci', scilimits=(-2,2))\n",
    "ax.set_xlabel(r'time / ps');\n",
    "ax.set_ylabel(r'signal / a.u.');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4. FFT plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "fft_data_mean = tplot.get_data_mean(tplot.fft_data)\n",
    "\n",
    "fig, axs = plt.subplots(ncols=2,figsize=(15, 5)) # set size of figure\n",
    "n = (tplot.fft_data.shape[0]+1)*2  # +1 possible\n",
    "mask = np.all([tplot.fft_data[:,0]>0.15, tplot.fft_data[:,0]<3], axis=0)\n",
    "\n",
    "for loop in range(tplot.fft_data.shape[1]-1):\n",
    "    if tplot.fft_data.shape[1] == 2:\n",
    "        axs[0].plot(tplot.fft_data[mask,0], 2*(tplot.fft_data[mask,loop+1]/n)**2)\n",
    "        axs[1].plot(tplot.fft_data[mask,0], 2*(tplot.fft_data[mask,loop+1]/n)**2)\n",
    "    else:\n",
    "        axs[0].plot(tplot.fft_data[mask,0], 2*(tplot.fft_data[mask,loop+1]/n)**2, label=\"file \"+str(tplot.filenames[loop][:3]))\n",
    "        axs[1].plot(tplot.fft_data[mask,0], 2*(tplot.fft_data[mask,loop+1]/n)**2, label=\"file \"+str(tplot.filenames[loop][:3]))\n",
    "\n",
    "if tplot.fft_data.shape[1] > 2:\n",
    "#    axs[0].plot(fft_data_mean[mask,0], 2*(fft_data_mean[mask,1]/n)**2, label=\"mean value of all loops\")\n",
    "#    axs[1].plot(fft_data_mean[mask,0], 2*(fft_data_mean[mask,1]/n)**2, label=\"mean value of all loops\")\n",
    "    axs[0].legend(loc='upper right', shadow=True)\n",
    "    axs[1].legend(loc='upper right', shadow=True)\n",
    "\n",
    "a = np.arange(3)\n",
    "ml = MultipleLocator(0.1)\n",
    "axs[0].xaxis.set_minor_locator(ml)\n",
    "axs[0].xaxis.set_tick_params(which='minor')\n",
    "axs[0].set_xlabel(r'frequency / THz')\n",
    "axs[0].set_ylabel(r'Power as MSA')\n",
    "axs[0].set_xlim([0.15,3])\n",
    "axs[0].ticklabel_format(axis='y', style='sci', scilimits=(-2,2))\n",
    "\n",
    "axs[1].xaxis.set_minor_locator(ml)\n",
    "axs[1].xaxis.set_tick_params(which='minor')\n",
    "axs[1].set_xlabel(r'frequency / THz')\n",
    "axs[1].set_ylabel(r'Power as MSA')\n",
    "axs[1].set_xlim([0.15,3])\n",
    "axs[1].ticklabel_format(axis='y', style='sci', scilimits=(-2,2))\n",
    "axs[1].set_yscale('log')\n",
    "if tplot.fft_data.shape[1] >= 4:\n",
    "    axs[1].legend(loc='lower left', shadow=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}