{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Superradiant light emission (Dicke superradiance)\n", "\n", "Notebook author: Nathan Shammah (nathan.shammah at gmail.com)\n", "\n", "We consider a system of $N$ two-level systems (TLSs) with identical frequency $\\omega_{0}$, which can emit collectively at a rate $\\gamma_\\text{CE}$ [1], and suffer from dephasing and local losses at rates $\\gamma_\\text{D}$ and $\\gamma_\\text{E}$, respectively. The dynamics can be written as\n", "\\begin{eqnarray}\n", "\\dot{\\rho} &=&-i\\lbrack \\omega_{0}J_z,\\rho \\rbrack\n", "+\\frac{\\gamma_\\text {CE}}{2}\\mathcal{L}_{J_{-}}[\\rho]\n", "+\\sum_{n=1}^{N}\\frac{\\gamma_\\text{D}}{2}\\mathcal{L}_{J_{z,n}}[\\rho]\n", "+\\frac{\\gamma_\\text{E}}{2}\\mathcal{L}_{J_{-,n}}[\\rho]\n", "\\end{eqnarray}\n", "\n", "When $\\gamma_\\text{E}=\\gamma_\\text{D}=0$ this dynamics is the classical superradiant master equation.\n", "In this limit, a system initially prepared in the fully-excited state undergoes superradiant light emission whose peak intensity scales proportionally to $N^2$.\n", "\n", "This dynamics has been studied in Refs. [2-4] and implemented in various quantum optical platforms, including in the solid state [5-10]. A discussion of the difference between superradiant phase transition (typical of the Dicke model) and Dicke superradiance is present in Refs. [3] and [11].\n", "\n", "Below, using PIQS [4] and QuTiP [12], we investigate the time evolution of the collective dynamics for an ensemble initialized in different initial quantum states.\n", "\n", "Note that in the table above and in $\\texttt{qutip.piqs}$ functions, the Lindbladian $\\mathcal{L}[\\rho]$ is written with a factor 1/2 with respect to $\\mathcal{L}_{A}[\\rho]$ reported in the LaTeX math equations, in order to have the Lindbladian and full Liouvillian matrix consistently defined by the rates $\\gamma_\\alpha$. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from time import clock\n", "import matplotlib.pyplot as plt\n", "import scipy\n", "\n", "from qutip import *\n", "from qutip.piqs import *\n", "\n", "from scipy.sparse import load_npz, save_npz" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The number of Dicke states is 121\n" ] } ], "source": [ "N = 20\n", "ntls = N\n", "nds = num_dicke_states(N)\n", "print(\"The number of Dicke states is\", nds)\n", "[jx, jy, jz] = jspin(N)\n", "jp = jspin(N, \"+\")\n", "jm = jspin(N, \"-\")\n", "system = Dicke(N = N)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "a = 1/np.sqrt(2)\n", "b = 1/np.sqrt(2)\n", "css_symmetric = css(N, a, b)\n", "css_antisymmetric = css(N, a,-b)\n", "excited_ = dicke(N, N/2,N/2)\n", "superradiant = dicke(N,N/2,0)\n", "subradiant = dicke(N,j_min(N),-j_min(N))\n", "ground_ = dicke(N,N/2,-N/2)\n", "ghz_ = ghz(N)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Time (in seconds) to generate the Liouvillian for N = 20 TLSs: 0.05499199999999993\n" ] } ], "source": [ "# here we set the initial coefficients\n", "gE = 0 # local emission\n", "gD = 0 # local dephasing\n", "gP = 0 # local pumping\n", "gCE = 1 # collective emission\n", "gCD = 0 # collective dephasing\n", "gCP = 0 # collective pumping\n", "w0 = 1 # bare frequency\n", "wi = 0 # coherent drive frequency\n", "\n", "# spin hamiltonian\n", "h0 = w0 * jz\n", "hint = wi * jx\n", "h = h0 #+ hint\n", "\n", "#set initial conditions for spins by initializing the system and building the Liouvillian matrix\n", "system = Dicke(hamiltonian = h, \n", " N = N, \n", " emission = gE, \n", " pumping = gP, \n", " dephasing = gD, \n", " collective_emission = gCE, \n", " collective_pumping = gCP, \n", " collective_dephasing = gCD)\n", "clock_t0 = clock()\n", "lind = system.lindbladian()\n", "liouv = system.liouvillian()\n", "clock_tf = clock()\n", "dt_clock = clock_tf - clock_t0\n", "print(\"Time (in seconds) to generate the Liouvillian for N = 20 TLSs:\", dt_clock)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Elapsed time (in seconds) for this run: 1.4128720000000001\n", "Elapsed time (in seconds) for this run: 1.3064499999999994\n", "Elapsed time (in seconds) for this run: 1.2567909999999998\n", "Elapsed time (in seconds) for this run: 1.333939\n", "Elapsed time (in seconds) for this run: 0.5167439999999992\n", "Elapsed time (in seconds) for this run: 1.3920459999999997\n" ] } ], "source": [ "## Solution of the dynamics for different initial conditions\n", "\n", "# parameters for the time integration of the dynamics\n", "nt = 1001\n", "td0 = np.log(N)/(N*gCE) # delay time is used as a reference\n", "tmax = 10 * td0\n", "t = np.linspace(0, tmax, nt)\n", "\n", "# initial states \n", "rho01 = excited_\n", "rho02 = superradiant\n", "rho03 = css_symmetric\n", "rho04 = css_antisymmetric\n", "rho05 = subradiant\n", "rho06 = ghz_\n", "\n", "#Excited\n", "clock_t0 = clock()\n", "result1 = mesolve(liouv, rho01, t, [], e_ops = [jz, jp*jm, jz**2], \n", " options = Options(store_states=True))\n", "rhot1 = result1.states\n", "jz_t1 = result1.expect[0]\n", "jpjm_t1 = result1.expect[1]\n", "jz2_t1 = result1.expect[2]\n", "clock_tf = clock()\n", "dt_clock = clock_tf - clock_t0\n", "print(\"Elapsed time (in seconds) for this run: \", dt_clock)\n", "\n", "#Superradiant\n", "clock_t0 = clock()\n", "result2 = mesolve(liouv, rho02, t, [], e_ops = [jz, jp*jm, jz**2], \n", " options = Options(store_states=True))\n", "rhot2 = result2.states\n", "jz_t2 = result2.expect[0]\n", "jpjm_t2 = result2.expect[1]\n", "jz2_t2 = result2.expect[2]\n", "clock_tf = clock()\n", "dt_clock = clock_tf - clock_t0\n", "print(\"Elapsed time (in seconds) for this run: \", dt_clock)\n", "\n", "#CSS Symmetric\n", "clock_t0 = clock()\n", "result3 = mesolve(liouv, rho03, t, [], e_ops = [jz, jp*jm, jz**2], \n", " options = Options(store_states=True))\n", "rhot3 = result3.states\n", "jz_t3 = result3.expect[0]\n", "jpjm_t3 = result3.expect[1]\n", "jz2_t3 = result3.expect[2]\n", "clock_tf = clock()\n", "dt_clock = clock_tf - clock_t0\n", "print(\"Elapsed time (in seconds) for this run: \", dt_clock)\n", "\n", "#CSS Antisymmetric\n", "clock_t0 = clock()\n", "result4 = mesolve(liouv, rho04, t, [], e_ops = [jz, jp*jm, jz**2], \n", " options = Options(store_states=True))\n", "rhot4 = result4.states\n", "jz_t4 = result4.expect[0]\n", "jpjm_t4 = result4.expect[1]\n", "jz2_t4 = result4.expect[2]\n", "clock_tf = clock()\n", "dt_clock = clock_tf - clock_t0\n", "print(\"Elapsed time (in seconds) for this run: \", dt_clock)\n", "\n", "#Subradiant\n", "clock_t0 = clock()\n", "result5 = mesolve(liouv, rho05, t, [], e_ops = [jz, jp*jm, jz**2], \n", " options = Options(store_states=True))\n", "rhot5 = result5.states\n", "jz_t5 = result5.expect[0]\n", "jpjm_t5 = result5.expect[1]\n", "jz2_t5 = result5.expect[2]\n", "clock_tf = clock()\n", "dt_clock = clock_tf - clock_t0\n", "print(\"Elapsed time (in seconds) for this run: \", dt_clock)\n", "\n", "#GHZ\n", "clock_t0 = clock()\n", "result6 = mesolve(liouv, rho06, t, [], e_ops = [jz, jp*jm, jz**2], \n", " options = Options(store_states=True))\n", "rhot6 = result6.states\n", "jz_t6 = result6.expect[0]\n", "jpjm_t6 = result6.expect[1]\n", "jz2_t6 = result6.expect[2]\n", "clock_tf = clock()\n", "dt_clock = clock_tf - clock_t0\n", "print(\"Elapsed time (in seconds) for this run: \", dt_clock)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Visualization" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "