C4_Swabian_Custom_measurements.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "274dd5c7-3519-44cf-95bc-1afc7d3ccc2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import TimeTagger\n",
    "import numpy as np\n",
    "%matplotlib ipympl\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "import numba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "90a20508-b722-45c7-bdc4-e2b1c5eac6c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dump_file = r\"Z:\\PriyaM\\swabian_data\\20230712_tissue\\test_tissue_2023-07-12_154752.1.ttbin\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bd0bbca5-b755-4d03-a85d-66c5c60f6dd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "tagger = TimeTagger.createTimeTaggerVirtual()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a53c62a4-ce9c-408c-b2aa-1abae02a828e",
   "metadata": {},
   "outputs": [],
   "source": [
    "laser = 1\n",
    "frame = 3 \n",
    "line = 2\n",
    "photon = 4"
   ]
  },
  {
   "cell_type": "raw",
   "id": "20b4c8bc-ceeb-4c37-b5e3-282f380f514a",
   "metadata": {},
   "source": [
    "The class CustomMeasurement allows you to access the raw time tag stream with very little overhead. \n",
    "By inheriting from CustomMeasurement, you can implement your fully customized measurement class. \n",
    "The CustomMeasurement.process() method of this class will be invoked as soon as new data is available."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b922504-b1c7-486b-9d63-be088f83e763",
   "metadata": {
    "tags": []
   },
   "source": [
    "# access indiv tags"
   ]
  },
  {
   "cell_type": "raw",
   "id": "cc5dab77-dd57-46d3-b3f1-8fae575b947c",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "source": [
    "class timeTaken(TimeTagger.CustomMeasurement):\n",
    "    \"\"\"\n",
    "    CustomMeasurement that gets channel_1/channel_2.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, tagger):\n",
    "        TimeTagger.CustomMeasurement.__init__(self, tagger)\n",
    "        self.data = 0\n",
    "        self.register_channel(4)\n",
    "        self.clear_impl()\n",
    "        self.finalize_init()      \n",
    "        \n",
    "\n",
    "    def __del__(self):\n",
    "        # The measurement must be stopped before deconstruction to avoid\n",
    "        # concurrent measure() calls\n",
    "        self.stop()\n",
    "\n",
    "    def getData(self):\n",
    "        # lock this instance to avoid conflicting results while measure is\n",
    "        # running apart.\n",
    "        with self.mutex:            \n",
    "            data = self.data\n",
    "        return data\n",
    "\n",
    "    def getIndex(self):\n",
    "        # this method does not depend on the internal state, so there is no\n",
    "        # need for a lock\n",
    "        return 0\n",
    "    \n",
    "    def clear_impl(self):\n",
    "        self.data = 0\n",
    "\n",
    "    \n",
    "    \n",
    "    def process(self, incoming_tags, begin_time, end_time):\n",
    "        # the lock is already acquired\n",
    "        # self.data is provided as reference, so it must not be accessed\n",
    "        # anywhere else without locking the mutex.\n",
    "        # incoming_tags is provided as a read-only reference. The storage will\n",
    "        # be deallocated after this call, so you must not store a reference to\n",
    "        # this object. Make a copy instead.\n",
    "        \n",
    "        #In Python, the incoming_tags are a structured Numpy array. \n",
    "        #You can access single tags as well as arrays of tag entries directly:\n",
    "        #first_tag = incoming_tags[0]\n",
    "        #all_timestamps = incoming_tags['time']\n",
    "        #print(incoming_tags[0])\n",
    "        \n",
    "        #for tag in incoming_tags:\n",
    "        #    self.data += 1\n",
    "        data= np.unique(incoming_tags[\"channel\"])\n",
    "        self.data = len(data)\n",
    "        \n",
    "        #print(len(incoming_tags))\n",
    "        #incoming_tags[\"channel\"]\n",
    "        \n",
    "        #self.index = PhotonMedian.fast_process(            incoming_tags,            self.data,            self.count_channel,            self.click_channel,            self.index)\n",
    "\n",
    "        \n",
    "        \n",
    "tagger.reset()\n",
    "times  = timeTaken(tagger)\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file,duration=20E12)\n",
    "tagger.waitForCompletion()\n",
    "times.getData(),times.getIndex()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9529dcb4-5d49-4376-8bd2-f96e02d6e377",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3562a2f1-0dfc-42a6-a3a4-7a0a4cf1b91c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "db70989d-7f7d-4720-b061-4a82a60dbd43",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "d62f4fd1-0d1d-4202-8ad1-f50657114807",
   "metadata": {},
   "outputs": [],
   "source": [
    "class timeTaken2(TimeTagger.CustomMeasurement):\n",
    "    \"\"\"\n",
    "    CustomMeasurement that gets channel_1/channel_2.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, tagger, channels):\n",
    "        TimeTagger.CustomMeasurement.__init__(self, tagger)\n",
    "        \n",
    "        \n",
    "        #not needed unless accessing channels outside of this\n",
    "        self.channels = list(channels)\n",
    "        \n",
    "        self.counts = [] \n",
    "        \n",
    "        #need to register what channels are being looked at\n",
    "        for channel in channels:\n",
    "                    self.register_channel(channel)\n",
    "                \n",
    "        #only need this if some variable isn't being cleared in initialization\n",
    "        #self.clear_impl()\n",
    "\n",
    "        # At the end of a Measurement construction we must indicate that we\n",
    "        # have finished\n",
    "        self.finalize_init()\n",
    "\n",
    "\n",
    "    def getData(self):\n",
    "        # lock this instance to avoid conflicting results while measure is\n",
    "        # running apart.\n",
    "        with self.mutex:\n",
    "            counts = self.counts \n",
    "        return counts\n",
    "       \n",
    "    \n",
    "    #create own clear\n",
    "    #def clear_impl(self):\n",
    "        # the lock is already acquired\n",
    "        #self.counts =* 0\n",
    "        \n",
    "\n",
    "\n",
    "    def process(self, incoming_tags, begin_time, end_time):\n",
    "        # the lock is already acquired\n",
    "        # self.data is provided as reference, so it must not be accessed\n",
    "        # anywhere else without locking the mutex.\n",
    "        # incoming_tags is provided as a read-only reference. The storage will\n",
    "        # be deallocated after this call, so you must not store a reference to\n",
    "        # this object. Make a copy instead.\n",
    "        \n",
    "        \n",
    "        channel_numbers = incoming_tags['time']\n",
    "        for channel_number in channel_numbers: \n",
    "            self.counts.append(channel_number) \n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "cdd479f1-f83c-46a3-ab92-3170d76a446b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tagger.reset()\n",
    "\n",
    "timeTaken_pho = timeTaken2(tagger, channels=[photon])\n",
    "\n",
    "\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file)\n",
    "tagger.waitForCompletion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "d1d9b1bc-2950-45c5-9928-7f1cce67d547",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sync measurements class??\n",
    "\n",
    "tagger.reset()\n",
    "sync = TimeTagger.SynchronizedMeasurements(tagger)\n",
    "\n",
    "timeTaken_pho = timeTaken2(tagger, channels=[photon])\n",
    "timeTaken_frame = timeTaken2(tagger, channels=[frame])\n",
    "timeTaken_laser = timeTaken2(tagger, channels=[laser])\n",
    "timeTaken_line = timeTaken2(tagger, channels=[line])\n",
    "timeTaken_pho_frame = timeTaken2(tagger, channels=[photon, frame])\n",
    "timeTaken_line_las = timeTaken2(tagger, channels=[line, laser])\n",
    "\n",
    "tests = [\n",
    "timeTaken_pho,\n",
    "timeTaken_frame, \n",
    "timeTaken_laser, \n",
    "timeTaken_line, \n",
    "timeTaken_pho_frame, \n",
    "timeTaken_line_las]\n",
    "\n",
    "for test in tests:\n",
    "    sync.registerMeasurement(test)\n",
    "\n",
    "sync.start()\n",
    "\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file, duration=10E12)\n",
    "tagger.waitForCompletion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "df6a53d1-6d6a-40ae-9879-0c3dd6ab70b5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sync measurements class??\n",
    "\n",
    "tagger.reset()\n",
    "\n",
    "timeTaken_pho = timeTaken2(tagger, channels=[photon])\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file, duration=10E12)\n",
    "tagger.waitForCompletion()\n",
    "\n",
    "tagger.reset()\n",
    "timeTaken_frame = timeTaken2(tagger, channels=[frame])\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file, duration=10E12)\n",
    "tagger.waitForCompletion()\n",
    "\n",
    "tagger.reset()\n",
    "timeTaken_laser = timeTaken2(tagger, channels=[laser])\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file, duration=10E12)\n",
    "tagger.waitForCompletion()\n",
    "\n",
    "tagger.reset()\n",
    "timeTaken_line = timeTaken2(tagger, channels=[line])\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file, duration=10E12)\n",
    "tagger.waitForCompletion()\n",
    "\n",
    "tagger.reset()\n",
    "timeTaken_pho_frame = timeTaken2(tagger, channels=[photon, frame])\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file, duration=10E12)\n",
    "tagger.waitForCompletion()\n",
    "\n",
    "tagger.reset()\n",
    "timeTaken_line_las = timeTaken2(tagger, channels=[line, laser])\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file, duration=10E12)\n",
    "tagger.waitForCompletion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "e2c6f8f6-f113-4ce6-bbaa-2fdc0f891cef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2200805 0.006342801566 9.99997945342\n"
     ]
    }
   ],
   "source": [
    "print(len(timeTaken_pho.getData()), timeTaken_pho.getData()[0]/1E12, timeTaken_pho.getData()[-1]/1E12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "787875f4-3511-4d44-b107-3b94fb520faf",
   "metadata": {},
   "outputs": [],
   "source": [
    "tests = [\n",
    "timeTaken_pho,\n",
    "timeTaken_frame, \n",
    "timeTaken_laser, \n",
    "timeTaken_line, \n",
    "timeTaken_pho_frame, \n",
    "timeTaken_line_las]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "5d2ee925-dbc7-48b4-ac14-83383e69c1aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4] : 2200805 0.006342801566 9.99997945342\n",
      "-----------------\n",
      "[3] : 3 8.358713276442 9.601111128023\n",
      "-----------------\n",
      "[1] : 2198936 0.006342804871 9.999979462735\n",
      "-----------------\n",
      "[2] : 883 7.804070943239 9.99865513318\n",
      "-----------------\n",
      "[4, 3] : 2200808 0.006342801566 9.99997945342\n",
      "-----------------\n",
      "[2, 1] : 2199819 0.006342804871 9.999979462735\n",
      "-----------------\n"
     ]
    }
   ],
   "source": [
    "for test in tests:\n",
    "    print(test.channels, \":\", len(test.getData()), test.getData()[0]/1E12, test.getData()[-1]/1E12)\n",
    "    print(\"-----------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "39ee9fad-7d5a-48c2-b19b-0b50e7554f28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeTaken_frame.getCaptureDuration()//1E12"
   ]
  },
  {
   "cell_type": "raw",
   "id": "dcd4448f-c469-4227-a00c-be202e4cbc7d",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "source": [
    "class timeTaken(TimeTagger.CustomMeasurement):\n",
    "    \"\"\"\n",
    "    CustomMeasurement that gets channel_1/channel_2.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, tagger):\n",
    "        TimeTagger.CustomMeasurement.__init__(self, tagger)\n",
    "\n",
    "\n",
    "        self.clear_impl()\n",
    "\n",
    "        # At the end of a Measurement construction we must indicate that we\n",
    "        # have finished\n",
    "        self.finalize_init()\n",
    "        self.data = 0\n",
    "\n",
    "    def __del__(self):\n",
    "        # The measurement must be stopped before deconstruction to avoid\n",
    "        # concurrent measure() calls\n",
    "        self.stop()\n",
    "\n",
    "    def getData(self):\n",
    "        # lock this instance to avoid conflicting results while measure is\n",
    "        # running apart.\n",
    "        with self.mutex:            \n",
    "            return self.data\n",
    "\n",
    "    def getIndex(self):\n",
    "        # this method does not depend on the internal state, so there is no\n",
    "        # need for a lock\n",
    "        return 0\n",
    "\n",
    "    def clear_impl(self):\n",
    "        # the lock is already acquired\n",
    "        0 \n",
    "\n",
    "    def on_start(self):\n",
    "        # the lock is already acquired\n",
    "        pass\n",
    "\n",
    "    def on_stop(self):\n",
    "        # the lock is already acquired\n",
    "        pass\n",
    "\n",
    "    @staticmethod\n",
    "    @numba.jit(nopython=True, nogil=True)\n",
    "    def fast_process(\n",
    "            tags,\n",
    "            data,\n",
    "            count_channel,\n",
    "            click_channel,\n",
    "            index):\n",
    "        \"\"\"\n",
    "        A precompiled version for better performance\n",
    "        nopython=True: Only a subset of the python syntax is supported.\n",
    "                       Avoid everything but primitives and numpy arrays.\n",
    "                       All slow operation will yield an exception\n",
    "        nogil=True:    This method will release the global interpreter lock. So\n",
    "                       this method can run in parallel with other python code\n",
    "        \"\"\"\n",
    "        for tag in tags:\n",
    "            if tag['type'] == TimeTagger.TagType.TimeTag and tag['channel'] == count_channel:\n",
    "                data[index] +=1\n",
    "            if tag['type'] == TimeTagger.TagType.TimeTag and tag['channel'] == click_channel:\n",
    "                index +=1\n",
    "                    \n",
    "        return index\n",
    "    \n",
    "    \n",
    "    def process(self, incoming_tags, begin_time, end_time):\n",
    "        # the lock is already acquired\n",
    "        # self.data is provided as reference, so it must not be accessed\n",
    "        # anywhere else without locking the mutex.\n",
    "        # incoming_tags is provided as a read-only reference. The storage will\n",
    "        # be deallocated after this call, so you must not store a reference to\n",
    "        # this object. Make a copy instead.\n",
    "        \n",
    "        #In Python, the incoming_tags are a structured Numpy array. \n",
    "        #You can access single tags as well as arrays of tag entries directly:\n",
    "        #first_tag = incoming_tags[0]\n",
    "        #all_timestamps = incoming_tags['time']\n",
    "        #print(incoming_tags[0])\n",
    "        \n",
    "        #for tag in incoming_tags:\n",
    "        #    self.data += 1\n",
    "        self.data = np.unique(incoming_tags[\"channel\"])\n",
    "        \n",
    "        #print(len(incoming_tags))\n",
    "        #incoming_tags[\"channel\"]\n",
    "        \n",
    "        #self.index = PhotonMedian.fast_process(            incoming_tags,            self.data,            self.count_channel,            self.click_channel,            self.index)\n",
    "\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "3279f181-a4e1-4239-8150-7a0ea12cc1dc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tagger.reset()\n",
    "times  = timeTaken(tagger)\n",
    "#times  = PhotonMean(tagger,channels=[photon, frame])\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file)\n",
    "tagger.waitForCompletion();\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7caea6d2-7b3f-4e4c-8ba7-f1014dd28db5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([], dtype=int32)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "times.getData()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d4b9a98-d336-4413-99dd-941c8bd3a7c7",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# channel/channel example (photon mean per channel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d9d70e3d-e10a-4d0f-b4e6-03cf76610b79",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = []\n",
    "\n",
    "photon = 4\n",
    "frame = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "44a877aa-c7ca-4611-b53a-09461b53c8fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PhotonMean(TimeTagger.CustomMeasurement):\n",
    "    \"\"\"\n",
    "    CustomMeasurement that gets channel_1/channel_2.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, tagger, channels):\n",
    "        TimeTagger.CustomMeasurement.__init__(self, tagger)\n",
    "        self.channels = list(channels)\n",
    "        self.counts = np.zeros((len(channels),), dtype=np.int32)\n",
    "\n",
    "        # Each used channel must be registered\n",
    "        for channel in channels:\n",
    "            self.register_channel(channel)\n",
    "\n",
    "        self.clear_impl()\n",
    "\n",
    "        # At the end of a Measurement construction we must indicate that we\n",
    "        # have finished\n",
    "        self.finalize_init()\n",
    "\n",
    "    def __del__(self):\n",
    "        # The measurement must be stopped before deconstruction to avoid\n",
    "        # concurrent measure() calls\n",
    "        self.stop()\n",
    "\n",
    "    def getData(self):\n",
    "        # lock this instance to avoid conflicting results while measure is\n",
    "        # running apart.\n",
    "        with self.mutex:\n",
    "            counts = np.array(self.counts)\n",
    "        if counts[1]!=0:\n",
    "            return counts[0]/counts[1]\n",
    "        else:\n",
    "            return \"no frames yet\"\n",
    "\n",
    "    def getIndex(self):\n",
    "        # this method does not depend on the internal state, so there is no\n",
    "        # need for a lock\n",
    "        return list(self.channels)\n",
    "\n",
    "    def clear_impl(self):\n",
    "        # the lock is already acquired\n",
    "        self.counts *= 0\n",
    "\n",
    "    def on_start(self):\n",
    "        # the lock is already acquired\n",
    "        pass\n",
    "\n",
    "    def on_stop(self):\n",
    "        # the lock is already acquired\n",
    "        pass\n",
    "\n",
    "    def process(self, incoming_tags, begin_time, end_time):\n",
    "        # the lock is already acquired\n",
    "        # self.data is provided as reference, so it must not be accessed\n",
    "        # anywhere else without locking the mutex.\n",
    "        # incoming_tags is provided as a read-only reference. The storage will\n",
    "        # be deallocated after this call, so you must not store a reference to\n",
    "        # this object. Make a copy instead.\n",
    "        channel_numbers, counts = np.unique(incoming_tags[\"channel\"], return_counts=True)\n",
    "        for channel_number, count in zip(channel_numbers, counts):\n",
    "            self.counts[self.channels.index(channel_number)] += count\n",
    "            \n",
    "            #if count%1E5:\n",
    "            #    arr.append(count)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7ebaad81-c651-4f0b-bc5e-40d035d7011c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tagger = TimeTagger.createTimeTaggerVirtual()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f4d3545e-3b18-4551-8556-f0bc02394acb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "slider_duration = widgets.IntSlider(\n",
    "    orientation='horizontal',\n",
    "    description='Duration (ps):',\n",
    "    step=.5E12,\n",
    "    min=0,\n",
    "    max=45E12\n",
    ")\n",
    "\n",
    "slider_begin = widgets.IntSlider(\n",
    "    orientation='horizontal',\n",
    "    description='Start at (ps):',\n",
    "    step=.5E12,\n",
    "    min=0,\n",
    "    max=45E12\n",
    ")\n",
    "\n",
    "slider_duration.layout.width = '60%'\n",
    "slider_begin.layout.width = '60%'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "38876655-0ffe-420c-8c3e-0d86af646ca3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8c345a4403014e87a1c349ad3b203a2d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='Start at (ps):', layout=Layout(width='60%'), max=4500000…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.update_duration(begin, duration)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def update_duration(begin, duration):\n",
    "    arr.clear()\n",
    "    tagger.reset()\n",
    "    photon_mean = PhotonMean(tagger, channels=[photon, frame])\n",
    "    \n",
    "    tagger.setReplaySpeed(-1)\n",
    "    replay = tagger.replay(dump_file, begin=begin, duration=duration)\n",
    "    tagger.waitForCompletion()\n",
    "    \n",
    "    photon_mean_data = photon_mean.getData()\n",
    "    print(\"mean photons per frame:\", photon_mean_data)\n",
    "    \n",
    "    print(\"length= \",len(arr), '\\n', arr)\n",
    "    \n",
    "widgets.interact(update_duration, begin=slider_begin, duration=slider_duration)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3397b5a-a14b-4d37-a6b3-3175cc6a9510",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "# Photon median"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ecef2cb3-4795-43c3-85a5-6022b355763f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PhotonMedian(TimeTagger.CustomMeasurement):\n",
    "    \"\"\"\n",
    "    counts number of photons per each frame, with getMedian() will return median photons\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, tagger, count_channel, click_channel):\n",
    "        TimeTagger.CustomMeasurement.__init__(self, tagger)\n",
    "        self.count_channel = count_channel\n",
    "        self.click_channel = click_channel\n",
    "\n",
    "        # The method register_channel(channel) activates\n",
    "        # that data from the respective channels is transferred\n",
    "        # from the Time Tagger to the PC.\n",
    "        self.register_channel(channel=count_channel)\n",
    "        self.register_channel(channel=click_channel)\n",
    "        \n",
    "\n",
    "        self.clear_impl()\n",
    "\n",
    "        # At the end of a CustomMeasurement construction,\n",
    "        # we must indicate that we have finished.\n",
    "        self.finalize_init()\n",
    "\n",
    "    def __del__(self):\n",
    "        # The measurement must be stopped before deconstruction to avoid\n",
    "        # concurrent process() calls.\n",
    "        self.stop()\n",
    "\n",
    "    def getData(self):\n",
    "        # Acquire a lock this instance to guarantee that process() is not running in parallel\n",
    "        # This ensures to return a consistent data.\n",
    "        with self.mutex:\n",
    "            return self.data.copy()[:self.index]\n",
    "\n",
    "    def getIndex(self):\n",
    "        # This method does not depend on the internal state, so there is no\n",
    "        # need for a lock.\n",
    "        arr = np.arange(0, self.index)\n",
    "        return arr\n",
    "    \n",
    "    def getMedian(self):\n",
    "        with self.mutex:\n",
    "            med1 = self.data.copy()[(self.index//2)]\n",
    "            med2 = self.data.copy()[((self.index-1)//2)]\n",
    "            return (med1+med2)/2\n",
    "\n",
    "    def clear_impl(self):\n",
    "        # The lock is already acquired within the backend.\n",
    "        self.index = 0\n",
    "        self.data = np.zeros((100,), dtype=np.uint64)\n",
    "\n",
    "    def on_start(self):\n",
    "        # The lock is already acquired within the backend.\n",
    "        pass\n",
    "\n",
    "    def on_stop(self):\n",
    "        # The lock is already acquired within the backend.\n",
    "        pass\n",
    "    \n",
    "    #In Python, it is advisable to use numpy.array() \n",
    "    #for calculation or even pre-compiled code with Numba if an explicit iteration of the tags is necessary\n",
    "\n",
    "    @staticmethod\n",
    "    @numba.jit(nopython=True, nogil=True)\n",
    "    def fast_process(\n",
    "            tags,\n",
    "            data,\n",
    "            count_channel,\n",
    "            click_channel,\n",
    "            index):\n",
    "        \"\"\"\n",
    "        A precompiled version for better performance\n",
    "        nopython=True: Only a subset of the python syntax is supported.\n",
    "                       Avoid everything but primitives and numpy arrays.\n",
    "                       All slow operation will yield an exception\n",
    "        nogil=True:    This method will release the global interpreter lock. So\n",
    "                       this method can run in parallel with other python code\n",
    "        \"\"\"\n",
    "        for tag in tags:\n",
    "            if tag['type'] == TimeTagger.TagType.TimeTag and tag['channel'] == count_channel:\n",
    "                data[index] +=1\n",
    "            if tag['type'] == TimeTagger.TagType.TimeTag and tag['channel'] == click_channel:\n",
    "                index +=1\n",
    "                    \n",
    "        return index\n",
    "\n",
    "    def process(self, incoming_tags, begin_time, end_time):\n",
    "        \"\"\"\n",
    "        Main processing method for the incoming raw time-tags.\n",
    "\n",
    "        The lock is already acquired within the backend.\n",
    "        self.data is provided as reference, so it must not be accessed\n",
    "        anywhere else without locking the mutex.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        incoming_tags\n",
    "            The incoming raw time tag stream provided as a read-only reference.\n",
    "            The storage will be deallocated after this call, so you must not store a reference to\n",
    "            this object. Make a copy instead.\n",
    "            Please note that the time tag stream of all channels is passed to the process method,\n",
    "            not only the ones from register_channel(...).\n",
    "        begin_time\n",
    "            Begin timestamp of the of the current data block.\n",
    "        end_time\n",
    "            End timestamp of the of the current data block.\n",
    "        \"\"\"\n",
    "        self.index = PhotonMedian.fast_process(\n",
    "            incoming_tags,\n",
    "            self.data,\n",
    "            self.count_channel,\n",
    "            self.click_channel,\n",
    "            self.index)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "c5c7c3ba-ccb5-4f69-ad5c-fffca1a569f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tagger.reset()\n",
    "\n",
    "photon_med  = PhotonMedian(tagger,count_channel= frame, click_channel= frame)\n",
    "#photon_mean = PhotonMean(tagger, channels=[photon, frame])\n",
    "\n",
    "tagger.setReplaySpeed(-1)\n",
    "replay = tagger.replay(dump_file)\n",
    "tagger.waitForCompletion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a2d1b0ae-2ae7-4583-9bba-1eeed62392ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1], dtype=uint64)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(photon_med.getData())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f44cf9e8-972a-4e09-8296-75a5f9c5aa73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(photon_med.getData())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "97d6cd03-342c-47be-bfa6-26612dbf6cc4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "578121.5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#photon_mean.getIndex(), photon_mean.getData()\n",
    "#photon_mean.\n",
    "photon_med.getMedian()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "48c600c3-2188-4ca7-ac05-39fc03a50ea1",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7da2d9aa-0cf9-47d7-ba75-c69e88062c50",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Median= 578121.5')"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "x_custom_histogram = photon_med.getIndex()\n",
    "y_custom_histogram = photon_med.getData()\n",
    "\n",
    "\n",
    "plt.plot(x_custom_histogram, y_custom_histogram,'r')\n",
    "#plt.plot(photon_mean.getIndex(), photon_mean.getData())\n",
    "\n",
    "plt.xlabel('frame #')\n",
    "plt.ylabel('# of photons')\n",
    "plt.title(('Median= '+ str(photon_med.getMedian())))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a360116-492a-452f-94eb-f024589454eb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "fc1d6390-604b-4dfc-a877-5cf12b5c4fb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "578121.5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "photon_med.getMedian()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4a8f7ce1-8749-44eb-9f53-7ef1c49a089b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "        17, 18, 19, 20, 21, 22, 23]),\n",
       " array([627228, 559951, 560180, 690452, 567660, 576280, 561581, 571035,\n",
       "        570756, 568827, 577448, 577240, 579003, 571183, 706105, 727837,\n",
       "        702348, 584937, 581351, 585613, 652867, 610461, 699495, 744894],\n",
       "       dtype=uint64))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_custom_histogram, y_custom_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f501d388-e753-4c1f-8563-c24297db0ec3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e222dc0-5517-46ce-a7d8-24d46bf74cc5",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}