From c28b66e44daf464626fef2dfedd9c71795fc94e0 Mon Sep 17 00:00:00 2001 From: ChristophHotter Date: Thu, 16 Apr 2026 11:46:25 -0400 Subject: [PATCH 1/4] rm .other --- ...pagation-delay__PRA2026_113-013730_fig4.jl | 256 -------- .other/Cat_state_SLH_HR.ipynb | 619 ------------------ ...tion-delay__PRA2026_113-013730_fig4__bu.jl | 175 ----- .other/backups/translate_fct_test.jl | 48 -- ...cat-state-generation__PRA2004_70-033604.jl | 184 ------ README.md | 1 + 6 files changed, 1 insertion(+), 1282 deletions(-) delete mode 100644 .other/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4.jl delete mode 100644 .other/Cat_state_SLH_HR.ipynb delete mode 100644 .other/backups/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4__bu.jl delete mode 100644 .other/backups/translate_fct_test.jl delete mode 100644 .other/xx-x_cat-state-generation__PRA2004_70-033604.jl diff --git a/.other/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4.jl b/.other/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4.jl deleted file mode 100644 index e6de942..0000000 --- a/.other/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4.jl +++ /dev/null @@ -1,256 +0,0 @@ -# # TODO - -# # Ramsey Interference with Delayed Fock Pulses - -# In this example, we reproduces the Ramsey-like interference pattern for a partially delayed input Fock state with `n = 9`, studied in [V. R. Christiansen and K. Mølmer, Phys. Rev. A 113, 013730 (2026)](https://journals.aps.org/pra/abstract/10.1103/3f3w-jmj8). -# We model a single input Fock pulse that is split on a 50/50 beam splitter (with vacuum padding on the second port), -# creating two channels that interact with the two-level system. We then scan the detuning to extract the excited-state -# population at the evaluation time used in the paper and compare with a coherent-state drive of the same mean photon number. - -using QuantumInputOutput -using SecondQuantizedAlgebra -using QuantumOptics -using SymbolicUtils -using LinearAlgebra -using PyPlot - -# - -## symbolic Hilbert space -hu = FockSpace(:u) -hd1 = FockSpace(:d1) -hd2 = FockSpace(:d2) -hs = NLevelSpace(:atom, 2) -h = hu ⊗ hd1 ⊗ hd2 ⊗ hs - -## symbolic operators -au = Destroy(h, :au, 1) -ad1 = Destroy(h, :ad_1, 2) -ad2 = Destroy(h, :ad_2, 3) -σ(i, j) = Transition(h, :σ, i, j, 4) - -## symbolic parameters -@rnumbers γ Δ r t -gu, gd1in, gd1out, gd2in, gd2out = cnumbers("gu gd1_{in} gd1_{out} gd2_{in} gd2_{out}") -nothing # hide - -# - -# Two-channel coupling to the atom with a beam splitter. -# The second input is a padding (vacuum) channel. - -G_u = concatenate(SLH(1, gu*au, 0), SLH(1, 0, 0)) - -S_bs = [r t; t -r] -G_bs = SLH(S_bs, [0, 0], 0) - -I2 = Matrix(I, 2, 2) -G_u_bs = concatenate(G_u ▷ G_bs, SLH(I2, [0, 0], 0)) - -I4 = Matrix(I, 4, 4) -G_d1_d2 = SLH(I4, [gd1in*ad1, gd2in*ad2, gd1out*ad1, gd2out*ad2], 0) # input at port 1 & 2, output at port 3 & 4 - -G_u_bs_d1_d2 = G_u_bs ▷ G_d1_d2 -nothing #hide - -# - -L_atom = [0, 0, √(γ/2)*σ(1, 2), √(γ/2)*σ(1, 2)] -G_atom = SLH(I4, L_atom, Δ*σ(2, 2)) - -G_u_bs_d1_d2_atom = G_u_bs_d1_d2 ▷ G_atom -H = hamiltonian(G_u_bs_d1_d2_atom) -L = lindblad(G_u_bs_d1_d2_atom) - -# - -## Interaction picture -H_pulse = G_u_bs_d1_d2.hamiltonian -H_int_ = simplify(H - H_pulse) - -## symbolic coefficient matrix $M(t)$ -M(i, j) = cnumber("M_{$(i)$(j)}") -a_ls = [au, ad1, ad2] -la = length(a_ls) -a_int_ls = [sum(M(i, j)*a_ls[j] for j = 1:la) for i = 1:la] -int_dict = Dict(a_ls .=> a_int_ls) - - -# ## delay cavity 1 -# M1(i,j) = cnumber("M1_{$(i)$(j)}") -# a1_ls = [au, ad1] -# la1 = length(a1_ls) -# a1_int_ls = [sum(M1(i,j)*a1_ls[j] for j=1:la1) for i=1:la1] - -# ## delay cavity 1 -# M2(i,j) = cnumber("M2_{$(i)$(j)}") -# a2_ls = [au, ad2] -# la2 = length(a2_ls) -# a2_int_ls = [sum(M2(i,j)*a2_ls[j] for j=1:la2) for i=1:la2] -# int_dict = Dict([a1_ls; a2_ls] .=> [a1_int_ls; a2_int_ls]) - -## substitute interaction picture operators -H_int = simplify(substitute_operators(H_int_, int_dict)) -L_int = [simplify(substitute_operators(L_, int_dict)) for L_ in L] - -## Pulse parameters -n = 5#9 -γ_ = 1.0 -τ = 0.5/γ_ -tw = π^(3/2) / (8*γ_*n) -tp = 4*tw - -u(t) = 1/(√(tw)*π^(1/4)) * exp(-(t - tp)^2 / (2*tw^2)) -ud1(t) = u(t-tp) -ud2(t) = u(t-tp-τ) - -Tend = 2tp + τ + 2tw -dt = tw/30 -T = [0:dt:Tend;] -t1 = 2tp + τ + 2tw - -rn = 1/√(2) -tn = 1/√(2) - -gu_ = u_to_gu(u, T) -gd1in_ = v_to_gv(u, T) -gd1out_ = u_to_gu(ud1, T) -gd2in_ = v_to_gv(u, T) -gd2out_ = u_to_gu(ud2, T) -dict_p_t = - Dict([gu, gd1in, gd1out, gd2in, gd2out] .=> [gu_, gd1in_, gd1out_, gd2in_, gd2out_]) -nothing # hide - -function interaction_picture_A_3modes(g1, g2, g3) - A(t) = - 0.5 * [ - 0 conj(g2(t)) * g1(t) g1(t) * conj(g3(t)); - -g2(t) * conj(g1(t)) 0 0; - -conj(g1(t)) * g3(t) 0 0 - ] - return A -end - -A_ud = interaction_picture_A_3modes(gu_, gd1in_, gd2in_) -M_t = interaction_picture_M(A_ud, T) - -M_ls = [M(i, j) for i = 1:la for j = 1:la] -M_t_ls = [t -> M_t(t)[i, j] for i = 1:la for j = 1:la] - -p_t_sym = [gu, gd1in, gd1out, gd2in, gd2out, M_ls...] -p_t_num = [gu_, gd1in_, gd1out_, gd2in_, gd2out_, M_t_ls...] -dict_p_t_int = Dict(p_t_sym .=> p_t_num) - - -# - -## numerical bases -bu = FockBasis(n) -bd1 = FockBasis(n) -bd2 = FockBasis(n) -bs = NLevelBasis(2) -b = bu ⊗ bd1 ⊗ bd2 ⊗ bs - - -dict_p_Δ(Δn) = Dict([γ, Δ, r, t] .=> [γ_, Δn, rn, tn]) -H_QO_Δ(Δn) = translate_qo(H_int, b; parameter = dict_p_Δ(Δn), time_parameter = dict_p_t_int) -L_QO_Δ(Δn) = [ - translate_qo(L_int[i], b; parameter = dict_p_Δ(Δn), time_parameter = dict_p_t_int) - for i = 1:length(L) -] -# H_QO_Δ(Δn) = translate_qo(H, b; parameter=dict_p_Δ(Δn), time_parameter=dict_p_t) -# L_QO_Δ(Δn) = [translate_qo(L[i], b; parameter=dict_p_Δ(Δn), time_parameter=dict_p_t) for i=1:length(L)] -nothing # hide -# - -ψ0_fock = fockstate(bu, n) ⊗ fockstate(bd1, 0) ⊗ fockstate(bd2, 0) ⊗ nlevelstate(bs, 1) - -# - -σ22_QO = translate_qo(σ(2, 2), b) -au_QO = translate_qo(au, b) -ad1_QO = translate_qo(ad1, b) -ad2_QO = translate_qo(ad2, b) - -Δn = 0 -H_QO = H_QO_Δ(Δn) -L_QO = L_QO_Δ(Δn) - -input_output = - (t, ρ) -> ( - H_QO(t), - [L_QO[i](t) for i = 1:length(L_QO)], - [dagger(L_QO[i](t)) for i = 1:length(L_QO)], - ) -t_, ρt = timeevolution.master_dynamic(T, ψ0_fock, input_output) - -expect(au_QO'au_QO, ρt) - -figure(111) -plot(T, expect(au_QO'au_QO, ρt)) -plot(T, expect(ad1_QO'ad1_QO, ρt)) -plot(T, expect(ad2_QO'ad2_QO, ρt)) - - -expect(σ22_QO, ρt[end]) - -## TODO: the simulation is correct; next step: use operators b1 and b2 to eliminate one mode (see paper, ask Victor) - -## Detuning scan and excited-state population at t1. -Δ_ls = range(-20γ_, 20γ_, length = 80) -Δ_ls = range(0γ_, 20γ_, length = 40) -pop_fock = zeros(length(Δ_ls)) -pop_coh = zeros(length(Δ_ls)) -idx_t1 = findmin(abs.(T .- t1))[2] -using ProgressMeter -prog = Progress(length(Δ_ls)) - -for (it, Δn) in enumerate(Δ_ls) - Δn = Δ_ls[it] - - H_QO = H_QO_Δ(Δn) - L_QO = L_QO_Δ(Δn) - - input_output = - (t, ρ) -> ( - H_QO(t), - [L_QO[i](t) for i = 1:length(L_QO)], - [dagger(L_QO[i](t)) for i = 1:length(L_QO)], - ) - - t_, ρt = timeevolution.master_dynamic([T[1], T[end]], ψ0_fock, input_output) - # pop_fock[it] = real(expect(σ22_QO, ρt[idx_t1])) - pop_fock[it] = real(expect(σ22_QO, ρt[end])) - - # t_, ρt = timeevolution.master_dynamic(T, ψ0_coh, input_output) - # pop_coh[it] = real(expect(σ22_QO, ρt[idx_t1])) - next!(prog) -end -nothing # hide - -# - -pygui(true) -close("ramsey-population") # hide -figure("ramsey-population") -plot(Δ_ls, pop_fock, label = "Fock, n=$(n)") -## plot([-Δ_ls; Δ_ls], [pop_fock; pop_fock], label="Fock, n=$(n)") -## plot(Δ_ls, pop_coh, ls="--", label="coherent, ⟨n⟩=9") -xlabel("detuning Δ/γ") -ylabel(L"\langle \sigma^{22} \rangle (t_1)") -grid(true) -legend() -tight_layout() - -# - -# ## Package versions - -using InteractiveUtils -versioninfo() - -using Pkg -Pkg.status( - ["QuantumInputOutput", "SecondQuantizedAlgebra", "QuantumOptics", "PyPlot"], - mode = PKGMODE_MANIFEST, -) diff --git a/.other/Cat_state_SLH_HR.ipynb b/.other/Cat_state_SLH_HR.ipynb deleted file mode 100644 index 6e5c2c3..0000000 --- a/.other/Cat_state_SLH_HR.ipynb +++ /dev/null @@ -1,619 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m DiffEqBaseChainRulesCoreExt\n", - "\u001b[36m\u001b[1m Info\u001b[22m\u001b[39m Given DiffEqBaseChainRulesCoreExt was explicitly requested, output will be shown live \u001b[0K\n", - "\u001b[0KWARNING: Method definition rrule(typeof(SciMLBase.numargs), Any) in module SciMLBaseChainRulesCoreExt at /home/helmut/.julia/packages/SciMLBase/J3OUh/ext/SciMLBaseChainRulesCoreExt.jl:14 overwritten in module DiffEqBaseChainRulesCoreExt at /home/helmut/.julia/packages/DiffEqBase/cggak/ext/DiffEqBaseChainRulesCoreExt.jl:10.\n", - "\u001b[0KERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", - "\u001b[33m ? \u001b[39m\u001b[90mDiffEqBase → DiffEqBaseChainRulesCoreExt\u001b[39m\n", - "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling DiffEqBaseChainRulesCoreExt [b00db79b-61e3-50fb-b26f-2d35b2d9e4ed]\n", - "WARNING: Method definition rrule(typeof(SciMLBase.numargs), Any) in module SciMLBaseChainRulesCoreExt at /home/helmut/.julia/packages/SciMLBase/J3OUh/ext/SciMLBaseChainRulesCoreExt.jl:14 overwritten in module DiffEqBaseChainRulesCoreExt at /home/helmut/.julia/packages/DiffEqBase/cggak/ext/DiffEqBaseChainRulesCoreExt.jl:10.\n", - "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", - "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mSkipping precompilation since __precompile__(false). Importing DiffEqBaseChainRulesCoreExt [b00db79b-61e3-50fb-b26f-2d35b2d9e4ed].\n" - ] - } - ], - "source": [ - "# # Deterministic cat-state generation\n", - "\n", - "# [H. Ritsch, et al., Phys. Rev. A 70, 033804 (2004)](https://doi.org/10.1103%2FPhysRevA.70.033804)\n", - "# As usual, we start by loading the packages and specifying the system. \n", - "\n", - "using QuantumInputOutput\n", - "using SecondQuantizedAlgebra\n", - "using QuantumOptics\n", - "using QuantumCumulants\n", - "using LinearAlgebra\n", - "using PyPlot" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ℋ(cavity) ⊗ ℋ(atom) ⊗ ℋ(output)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "@rnumbers κ g γ Δa Δc\n", - "@cnumbers η gv\n", - "Natoms = 1\n", - "\n", - "hc = FockSpace(:cavity)\n", - "ha = NLevelSpace(:atom, 2)\n", - "hv = FockSpace(:output)\n", - "h = hc ⊗ ha ⊗ hv\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "a = Destroy(h, :a, 1) # cavity \n", - "σ(i, j) = Transition(h, \"σ\", i, j, 2) # two-level atom\n", - "av = Destroy(h, :a_v, 3) # output cavity\n", - "nothing # hide \n", - "\n", - "# We couple a classical drive into the cavity through the left mirror $(\\kappa_L)$. The decay through the right mirror can be added in several ways: with the `concatenate` rule, including it already in the initial cavity SLH triple or by simply including the decay term to the Lindblad by hand. In this example, we use the first option. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2-element Vector{SecondQuantizedAlgebra.QMul{Nothing}}:\n", - " sqrt(κ)*(a)\n", - " sqrt(γ)*(σ12)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "H_ac = -Δc*a'a - Δa*σ(2, 2) - g*(σ(2, 1)*a + σ(1, 2)*a') + η*σ(2, 1) + η'*σ(1, 2)\n", - "J = [√(κ)*a, √(γ)*σ(1, 2)]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Dict{SymbolicUtils.BasicSymbolic{Real}, Float64} with 4 entries:\n", - " γ => 0.25\n", - " κ => 8.0\n", - " Δc => 0.0\n", - " Δa => 0.0" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## numerical parameters\n", - "κ_ = 8.0 # 1.0\n", - "γ_ = 0.25\n", - "g_ = 50.0\n", - "Δa_ = 0.0\n", - "Δc_ = 0.0\n", - "\n", - "p_sym = [κ, γ, Δa, Δc]\n", - "p_num = [κ_, γ_, Δa_, Δc_]\n", - "dict_p = Dict(p_sym .=> p_num)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "η_t (generic function with 1 method)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Gaussian pulse (definiton?)\n", - "η0 = 20g_# 9g_\n", - "τ = 0.1/κ_\n", - "Tend = 40τ\n", - "\n", - "η_t(t) = η0*exp(-(t-4*τ)^2 / (1.1*τ^2))" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.000625" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "### rectangular pulse\n", - "# η0 = √(8)*g_\n", - "\n", - "T_pulse = 2π*τ \n", - "g_t(t) = (t [η_t, ηc_t,g_t,gc_t])\n", - "T = [0:0.00125:1;]*Tend\n", - "ΔT = T[2] - T[1]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3.9269908169872414" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "g_*T_pulse" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "σ_QO (generic function with 1 method)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## numerical basis\n", - "bc = FockBasis(16)\n", - "ba = NLevelBasis(2)\n", - "bv = FockBasis(16)\n", - "b = bc ⊗ ba ⊗ bv\n", - "#\n", - "a_QO = destroy(bc) ⊗ one(ba)\n", - "ad_QO = dagger(a_QO)\n", - "σ_QO(i, j) = one(bc) ⊗ transition(ba, i, j)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "ops_sym = [a, a', σ(2, 2), σ(1, 2), σ(2, 1)]\n", - "ops_QO = [a_QO, dagger(a_QO), σ_QO(2, 2), σ_QO(1, 2), σ_QO(2, 1)]\n", - "ops_dict = Dict(ops_sym .=> ops_QO);" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "H_QO =\n", - " translate_qo(H_ac, b; parameter = dict_p, time_parameter = dict_t, operators = ops_dict)\n", - "L_QO = translate_qo(√(κ)*a, b; parameter = dict_p, operators = ops_dict)\n", - "J_add_QO = √(γ_)*σ_QO(1, 2)\n", - "\n", - "J = [L_QO, J_add_QO]\n", - "Jd = dagger.(J);\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "input_output (generic function with 1 method)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function input_output(t, ρ)\n", - " H = H_QO(t)\n", - " return H, J, Jd\n", - "end\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "ψ0 = fockstate(bc, 0) ⊗ nlevelstate(ba, 1)\n", - "t_, ρt = timeevolution.master_dynamic(T, ψ0, input_output)\n", - "\n", - "n_t = real(expect(ad_QO*a_QO, ρt))\n", - "σ22_t = real(expect(σ_QO(2, 2), ρt))\n", - "tr_ρa2 = tr.(ptrace.(ρt, 1) .^ 2); " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "n_out = 2.3788009613175034\n" - ] - }, - { - "data": { - "text/plain": [ - "2.3788009613175034" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "n_out = sum(n_t)*κ_*ΔT\n", - "@show n_out" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/lib/python3/dist-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "close(\"n(t)\")\n", - "figure(\"n(t)\")\n", - "subplot(311)\n", - "plot(t_*g_, n_t)\n", - "plot(T*g_, η_t.(T)/η0*maximum(n_t), ls = \"--\", color = \"grey\")\n", - "grid(true)\n", - "xlabel(\"gt\")\n", - "ylabel(\"⟨a⁺a⟩\")\n", - "subplot(312)\n", - "plot(t_*g_, σ22_t)\n", - "grid(true)\n", - "xlabel(\"gt\")\n", - "ylabel(\"⟨σ²²⟩\")\n", - "subplot(313)\n", - "plot(t_*g_, tr_ρa2)\n", - "grid(true)\n", - "xlabel(\"gt\")\n", - "ylabel(\"tr(ρa²)\")\n", - "tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single_mode = 0.9974739077050487\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "0.9974739077050487" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Ls(t) = L_QO\n", - "g1_m = two_time_corr_matrix(T, ρt, input_output, Ls) # TODO: two_time_corr_matrix for Ls = const\n", - "\n", - "close(\"g1(t1,t2) matrix\") # hide\n", - "figure(\"g1(t1,t2) matrix\", figsize = (4.5, 3.5))\n", - "pcolormesh(T, T, real.(g1_m), cmap = \"inferno\")\n", - "xlabel(L\"\\gamma t_2\")\n", - "ylabel(L\"\\gamma t_1\")\n", - "colorbar(label = L\"g^{(1)}(t_1,t_2)\")\n", - "tight_layout()\n", - "\n", - "F = eigen(g1_m)\n", - "n_avg = real.(F.values)*ΔT\n", - "modes = F.vectors\n", - "v1_mode = (modes[:, end]) / √(ΔT)\n", - "\n", - "single_mode = n_avg[end]/n_out\n", - "@show single_mode\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Dict{SymbolicUtils.BasicSymbolic, Function} with 5 entries:\n", - " g => gc_t\n", - " η => η_t\n", - " gv => #83\n", - " conj(η) => ηc_t\n", - " conj(gv) => #1" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# time-dependent coupling for the output mode $v(t)$\n", - "gv_t = v_to_gv(v1_mode, T)\n", - "gvc_t = t -> conj(gv_t(t))\n", - "dict_t_2 = Dict([η, conj(η), gv, conj(gv), g, conj(g)] .=> \n", - " [η_t, ηc_t, gv_t, gvc_t, g_t, gc_t])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Operator(dim=578x578)\n", - " basis: [Fock(cutoff=16) ⊗ NLevel(N=2) ⊗ Fock(cutoff=16)]sparse([1, 2, 3, 4, 5, 6, 7, 8, 9, 10 … 552, 553, 554, 555, 556, 557, 558, 559, 560, 561], [18, 19, 20, 21, 22, 23, 24, 25, 26, 27 … 569, 570, 571, 572, 573, 574, 575, 576, 577, 578], ComplexF64[0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im … 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im, 0.5 + 0.0im], 578, 578)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# needed later # TODO: move down\n", - "G_ac = SLH(1, [√(κ)*a], H_ac)\n", - "G_v = SLH(1, [gv*av], 0)\n", - "G_cas = G_ac ▷ G_v\n", - "\n", - "H_2 = G_cas.hamiltonian\n", - "L_2 = G_cas.lindblad[1]\n", - "\n", - "H_QO_2 = translate_qo(H_2, b; parameter = dict_p, time_parameter = dict_t_2)\n", - "L_QO_2 = translate_qo(L_2, b; parameter = dict_p, time_parameter = dict_t_2)\n", - "J_add_QO_2 = translate_qo(√(γ)*σ(1, 2), b; parameter = dict_p)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "input_output_2 (generic function with 1 method)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function input_output_2(t, ρ)\n", - " H = H_QO_2(t)\n", - " J = [L_QO_2(t); J_add_QO_2]\n", - " return H, J, dagger.(J)\n", - "end\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.845575991174775 + 0.0im" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ψ0_2 = ψ0 ⊗ fockstate(bv, 0)\n", - "t_2, ρt_2 = timeevolution.master_dynamic(T, ψ0_2, input_output_2)\n", - "\n", - "av_QO_2 = translate_qo(av, b)\n", - "n_v1_t = real(expect(dagger(av_QO_2)*av_QO_2, ρt_2))\n", - "n_v1_t[end]\n", - "\n", - "ρ_end_output = ptrace(ρt_2[end], [1, 2])\n", - "\n", - "tr(ρ_end_output^2)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhUAAAGdCAYAAACl74FWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3df5AcdZ3/8dfs7yRkNyRxs8ZsQsA7iUYukmgMikIZFjg8D+ruhNKLFwWsFAHN5arUSF0RKOr2qgTNiQaIp6ByYMpTQa8iZrfuBK8CGkMid6fmK2LckM2SH4RdkpDd2d35/rGZ3en39E7PZ7p7fu3zUbW1+5nu6f507/TMez6f9+fTiVQqlRIAAEBINaWuAAAAqA4EFQAAIBIEFQAAIBIEFQAAIBIEFQAAIBIEFQAAIBIEFQAAIBIEFQAAIBJ1pa5ALqOjo+rt7dXMmTOVSCRKXR0AQBlLpVJ67bXXNH/+fNXUxPed+cyZMxoaGgq9nYaGBjU1NUVQo/JR1kFFb2+v2tvbS10NAEAFOXjwoBYsWBDLts+cOaM3TJumkxFsq62tTX/4wx+qKrAo66Bi5syZkqSDf/yjmpubS1ybbMlkUju7u9WxerXq6+tLXZ2KwrkLh/NXOM5d4cr93A0MDKh90aLxz444DA0N6aSkv5fUGGI7g5K+1NenoaEhgopiSXd5NDc3l21QMX36dDU3N5flBVbOOHfhcP4Kx7krXKWcu2J0l0+TFCYUqNaExrIOKgAAKEc1ChcYVGtQUa3HBQAAioyWCgAAHNFS4Y+gAgAARwQV/ggqAABwRFDhr1qPCwAAFBktFQAAOKKlwh9BBQAAjggq/FXrcQEAgCKjpQIAAEe0VPgjqAAAwFFC4QKDar3vdrUGSwAAoMhoqQAAwFFC4VobqrWlgqACAABHtWd/wjy/GtH9AQAAIkFLBQAAjhj94Y+gAgAARwQV/ggqAABwRFDhr1qPCwAAFBktFQAAOKKlwh9BBQAAjggq/FXrcQEAgCKjpQIAAEe0VPgjqAAAwBHTdPur1mAJAAAUGS0VAAA4qlG4+3dU6zd6ggoAAByRU+GPoAIAAEcEFf6q9bgAAECRFS2o6OzsVCKR0IYNG4q1SwAAYlETwU81Kkr3x+7du7Vt2zZddNFFxdgdAACxovvDX+zHdfLkSX30ox/V1772NZ177rlx7w4AAJRI7EHF+vXrdc0112j16tVx7woAgKKg+8NfrN0f3/nOd/Tcc89p9+7dea0/ODiowcHB8fLAwIAkKZlMKplMxlLHMJLDw57fyB/nLhzOX+E4d4Ur93NXzM8Juj/8xRZUHDx4UJ/+9Ke1c+dONTU15fWczs5O3XnnnVmP7+zu1vTp06OuYmS6urtLXYWKxbkLh/NXOM5d4cr13J0+fbrUVZjyEqlUKhXHhh9//HFdd911qq2dmHNsZGREiURCNTU1Ghwc9CyT/Fsq2tvbdezIETU3N8dRzVCSw8Pq6u7WFatXq76OKT9clMW5K9NvW5KkgHNSFuevQnHuCpfPuRuN+Dt4jUbzXndgYEBzW1vV398f22fGwMCAWlpatF1SmK+6pyVdL8Va11KI7Yr6wAc+oP/5n//xPPbxj39cF154oT772c9mBRSS1NjYqMbGxqzH6+vrVV9fH1dVQ6uvqyvr+pWzkp67RBnf0ifPDztee4Xj3BUu17krZVBRzP9nrcJN0x3mueUstm6dmTNnaunSpZ6fGTNmaM6cOVq6dGlcuwUAoGpt3bpVixcvVlNTk5YvX66f/exnk677/e9/X1dccYXe8IY3qLm5WatWrdJPfvKTWOtXrbkimAqGh8P9lLN8618Jx4KKMqqanD9B6xS7PnHvfzIJhRv5UUg76fbt27Vhwwbdfvvt2rt3ry699FJdffXV6unp8V3/6aef1hVXXKEdO3Zoz549uvzyy/UXf/EX2rt3bwF7z09ROxR/+tOfFnN3AADEohSjP774xS/qxhtv1E033SRJ2rJli37yk5/o/vvvV2dnZ9b6W7Zs8ZT/6Z/+SU888YR+9KMf6R3veEch1Q5ESwUAAI6imqdiYGDA85M5WCHT0NCQ9uzZo46ODs/jHR0d2rVrV151Hh0d1WuvvabZs2e7HKoTggoAAEqkvb1dLS0t4z9+LQ6SdOzYMY2MjGjevHmex+fNm6e+vr689nXvvffq1KlT+vCHPxy63pNhPBXKV9hcgWrKNQgaDeJ6rAylnLKKmXdQzaLq/jh48KBnSKnfCMhMCTNqLZVKZT3m57HHHtPmzZv1xBNPqLW11bm++eKdBQAAR1EFFc3NzXnNUzF37lzV1tZmtUocOXIkq/XC2r59u2688UZ997vfjf2WGYSsAACUuYaGBi1fvlxdXV2ex7u6unTJJZdM+rzHHntMa9eu1aOPPqprrrkm7mrSUoESGx4ufBIq1yb/MN0hYbtSou5uGBmZ+O13/sJ2l9A9UjXo7ohHKUZ/bNy4UWvWrNGKFSu0atUqbdu2TT09PVq3bp0kadOmTTp06JC+9a1vSRoLKD72sY/pX/7lX/Tud797vJVj2rRpamlpCVH7yfHOAQCAo4QKm2si8/murr/+eh0/flx33XWXDh8+rKVLl2rHjh1atGiRJOnw4cOeOSsefPBBDQ8Pa/369Vq/fv3443/3d3+nhx9+OETtJ0dQAQBAhbjlllt0yy23+C6zgUIp5oYiqAAAwBH3/vBHUIHiyezHzydHIWiduJdHKWwOw2TPL/QYXPdHjgXgUYqcikpQrccFAACKjK8fAAA4St9QLMzzqxFBBQAAjuj+8EdQgegU0r8/2TwL+WzPLo96/ULX9ROUk+C6PF2fM2fGlkWd8zDZ/vJdHyXDvBTFQVDhr1qPCwAAFBlfLwAAcERLhT+CChQuzDTZ6Wmmc20jqLvCtZxr+3EPP3Xt3ggqp7uMJjuPQc8P2r/rkFKGoJaNGo16ynSHxIOgwl+1HhcAACgyvk4AAOCoFPf+qAQEFQAAOGKabn8EFchf2FuN++Uw5MprKGY57PBUK+ocislyKk6elGprs5c3NeXef1jkWADwwZUOAIAjEjX9EVQAAOCIoMJftR4XAAAoMloqMLkocyhsuZCcijNn4lseds6LIGFzKGyORM3Z7wOnTo39bZfb+trlrvsPQo5F2bLzVljMY1EYbijmjysbAABHdH/4I6gAAMARQYU/ggpMiLO7w5bTf6enmZayuydcuzPClIO2bbkOKQ3b3WHLjY1jv0+dGhteGtTdEVS/qIeg0r1RMYK6R/zWrdHo+N90nyATVz4AAI5oqfBHUAEAgCOm6fZXrcESAAAoMloqkL8op8VO51KcOTM2zXT670xB5ZMnwy3PLAflb7gOMY06h8KWZ8wY+/3qq2M5FXb5Oefkrm9QDkXcORYMMa0aLjkZcStmXbj3hz+uZAAAHJFT4a9ajwsAABQZLRUAADiipcIfQcVUFvb23kHr55r7IZ+cCpsT4ZpD4VJ2nSMjbE5FUM6EzYnwy5FoaZH6+/2XW2GnGXed9yJo/+RYoMIRVPir1uMCAABFxtcBAAAccUMxfwQVyF8cQ0oHByfuuBmm+0IaG15Z6PKgrpW4uz+Cujts+dxzx7o/jh+XUqng+gV1j1hB3ROW6/kAKhzdH/640gEAcERQ4a9ajwsAABQZLRUAADiipcIfQcVU4tovHraca5jm6OjEY+mcCtchojZH4tix3MtzPd9lSm8pfE6Faw7FrFneciolnX++9MorY/kpcU8jbtmckLBDVhliigpDUOGvWo8LAAAUGeE/AACOaKnwR1ABAIAjggp/BBUoXJgci3ROxeDg2K27peC8Bpsj4VrOlXPhOiW4a85C0LTcNmfClu3+0lObv/rqxJwfufYfdTnof00OBDAlceUDAOCIlgp/BBUAADgiqPBXrccFAACKjJaKqSzsrc2DlucqZ85Tkc6pCDtPRVAORa6cioA5LVLJpKc8qtxstJ6or/c+YOehcM3ZSOdk9PePrRuUwxG03O6/2DkW3BodFSYhKZEo/LZgiVQqusqUEa5MAABc1dVNfCEqhN+NAKsAQQUAAK4IKnwRVFSzsN0bYW93nWt76aa/4eHJuz+CylHeKt10fwyapkl7pK7dH3Wm+6ThxAlPORHUvG/L06aN/e7vl5JJ9yGsQec2aBruqLvO6M4AqgJXMgAArqJoqahCBBUAALgiqPDFkFIAABAJWiqQvyhvjZ6O0jOnmHa5dXo+ZYcci6T51jDkXTMrpyIooyArpyJg/UZbt6CciFOnJn4PDQUPUXW9lXvUZXImUG1qa6WaEN/LR4MysyoTVzoAAK7q6ggqfND9AQAAIkFLBQAArmip8EVQgfjkO09FPuvnUw7KEzDLM6feDsqZCJtTYdnn15mcjtp8cyCGhyd+8lm/0HIQ1zlLyLFApSOo8EX3BwAAiESsQUVnZ6fe+c53aubMmWptbdW1116r/fv3x7lLAADiV1s71lpR6E9tbamPIBaxtkE+9dRTWr9+vd75zndqeHhYt99+uzo6OvTrX/9aM2bMiHPXKIVC5rEv5tz3psndc4fBSp+IJso7yBZSDtof3R1la9Thu2V63VHVOD0vSjWBk+QXSdjAIMzEWWUs1iv9ySef9JQfeughtba2as+ePXrf+94X564BAIgPQYWvooaa/f39kqTZs2cXc7cAAKAIitYmmUqltHHjRr33ve/V0qVLfdcZHBzU4ODgeHlgYECSlEwmlTR3eSwHybNNvMliNuG7CKpX5myWfuvbsl3flm02sy1ndDGkZ7D0/Fdt5G4zq+23Atuk3tDgLTc2est2Vsr0nT4lDQfcldSWzZFnCWqgtduzr+5RW1dzLMmzx5r+rfp67/r23NhzF/QtyXYH2bL93wa9Nly7T4K6o0J0V5X9dVtkLt0Yw8NJz+9SyNX9UdTPiRK1VGzdulVf+MIXdPjwYb3tbW/Tli1bdOmll/que/jwYf3DP/yD9uzZo9/97nf61Kc+pS1bthRe5zwULai49dZb9fzzz+u///u/J12ns7NTd955Z9bjO7u7NX369DirF0pXd3epq1CxujJza2yezfz5xa1MBepav744OzK3hs8qVyCu28J1d3eVugq+Tp8+XbydlSCo2L59uzZs2KCtW7fqPe95jx588EFdffXV+vWvf62FCxdmrT84OKg3vOENuv322/WlL32p8Lo6SKRS8Weo3XbbbXr88cf19NNPa/HixZOu59dS0d7ermNHjqi5uTnuajpLDg+rq7tbV6xerfpyTESLuqUi438jKXsuhPT9KNLs/SwylidTKXUNDuqKwUGNf8c+fty7ftTlI0cmXW6/4ZgjzboXiP2uZMv2u19DQNm0qSgxa5b3gXnzPMVkW5u61q3TFQ88oPpkUpozx7t+a6u3bJfbcktL7rKtjw0AbTmgpSVreVDLihXieiv76zZmYRIsh4eT6u7u0urVV6iurj74CUU2MDCg1ta56u/vj+0zY2BgQC0tLeq/+GI1hwgqBkZG1PLcc051XblypS6++GLdf//9448tWbJE1157rTo7O3M+97LLLtOyZcsqu6UilUrptttu0w9+8AP99Kc/zRlQSFJjY6Ma7ZuPpPr6etXb5t0yUl9XV571C4qEXSNlG2TYC8p2V9iyz/7qz/5Icm9it/WxTZ9DJhSwQdDrr0/6XNu9ERREBAUV9kKzZfvqSdgPXRvQna1vfTKp+qGh7GMP6poK+i5h/1euXVNBXVWuZSuCYKBsr9uYRTFqo66uPN+Ti1qn9JDSkNLd/GmTfQ4ODQ1pz549+tznPud5vKOjQ7t27Qpdj6jEmqi5fv16PfLII3r00Uc1c+ZM9fX1qa+vT69nvpkDAFBpwsxRkf6R1N7erpaWlvGfyVocjh07ppGREc0zrZbz5s1TX19f7Iebr1hbKtJNNJdddpnn8Yceekhr166Nc9coBddvm67PD7oduC3b24HbJvyMlo56myNgvvnb6Nt2LIXt/khkJI1Kyq67PbZ0d8OMGWMJqnb9EnzzB+Du4MGDnu4Pv1aKTAnTaphKpbIeK6XYuz8AAKg6Ga0NYTQ3N+eVUzF37lzV1tZmtUocOXIkq/WilLj3BwAAriLq/shXQ0ODli9frq4u78ibrq4uXXLJJVEeWSi0eSJ/UXZvpFuxMh9z7e6wTf5h5h0w+7bdIXUmD8iOBrGCEjWzujvmznUrp0dntLSMHbc9F0HdJ0GjL+gOAcrOxo0btWbNGq1YsUKrVq3Stm3b1NPTo3Xr1kmSNm3apEOHDulb3/rW+HP27dsnSTp58qSOHj2qffv2qaGhQW9961tjqSPvHAAAuAo7+qOA9IDrr79ex48f11133aXDhw9r6dKl2rFjhxYtWiRpbLKrnp4ez3Pe8Y53jP+9Z88ePfroo1q0aJEOHDhQeN1zIKgAAMBV2JyKAnMOb7nlFt1yyy2+yx5++GGf3RQ3t5GgAgAAVyUKKsodQQUmBF0gQTkLLhMapS+o2tqJiZXC5kyEGZIakHOQMDkWjXYiraC6BQ1vteWgnIr0jJhz5oxNdGWf75pjUYaTUyEe9t4ZpbqFOaoTVz4AAK5oqfBFUAEAgCuCCl+0ewEAgEjQUlHNbBRt+/2Dlgdtz7VfPbOcvsFVU9NETkXQXVJt3kBQDoYt27umZi4P2pZdbrcVNqfC5ky0teVePnv22O9588bOZdh5KsLOW0GORcWyORYWOReTCDuk1N7kr0pwpQMA4Cps90eVBhWEoAAAIBK0VAAA4IqWCl8EFYiOS796+oKqq5t8ngrLLg/KwbBlmweROfeEzUEwdwLMOjZ7q3Q7b4Vd324/KIciKKcinZMxf/7Y77A5EuU+DwU5GSWTmXOR/rtGo+N/T9mcC4IKX1P01QAAAKJG+A8AgCtaKnwRVEwlrkNMXbfnujy9Trr7I6jLIGx9bBdFru4P13Nhu1bCdn8sWJB7eUvLWP0XLRo7f0FdR1bUw4ddcav1qhE0JNWqmu6SsENKR0aiq0sZ4UoGAMBV2JaKKg0qqiRkBAAApUZLBQAArmip8EVQMZW5TtPtur1cy9NJSrW1Us3ZBjPXIaVBU2vb+uTKqQjat31u2FufB+VY2JwKW545c6z+Cxfm17cbVH9bthhCiohUTQ4GQYWvMv1vAQCASsPXAQAAXIUd/RG2ZbhMEVQAAOAqbPdHlXbxVedRoTBRz1MRdv+2bG8XHnD78KFhb++e3VzNyYHJF9p5J+y03ZbrnB+uORXnnecpjjZOk55/XqPzF2i0vj5w955jlbKnGbeq9FsUKo9LDoZrvgaiR1ABAIArWip8VedRAQAQJ4IKX9V5VJDkPhQr9qbDzCb1fOa9t8M8TXfH0KxWT7nvJe/qQS38bW3N43+3mu6FwLuU2u6BoCGZQVOO2+VmWu5Xhps95ZcPJSVJL744li9mq5Pdu+J9/nTTc5TFdv+UWXdI2b22AUgiqAAAwB0tFb6q86gAAIhT2CGltbXR1aWMEFQAAOCKlgpfVXdUYad0reS+17DHbp9f4zqNt12eq5zOqRgZmfjb7i8gp8KmPbzwgrd87Fju6njufL5itmfZdDtc1XIdcmqTHIKTIDzFA/u8iw8fHvv94otjdz63m7PVt8vPO8+bY1HjOg15UDliUb6203+Pqkajqqnoa16a2u95KD9VF1QAABA7Wip8VedRAQAQJ4IKX9xQDAAARKLiQ6Wob4ubub1y72sMe+yuM0uH3kFmOZWaeCyR8K+AKQ+pwVO2aQwHDuQuW5lpEWZaCP1pUA6ESdhIpZMcJpGw27M5GeZYX3nV+799yczB8cc/jt31/MUXx06lrZ49nqAZz2cH3fo96MVS5ByLqSzO9zw/5f4+WDKM/vBV8UEFAABFR/eHL7o/AABAJCouVIq66W8qcR0RWlfnOMQ0qJw5TDHd/XHmzET3h22CN/uz024HDSm15VzVufBC77I/bWuafGWfnb+i3ObYvpiAOcTtYtv98eKLE90fIyPBs4bb3he7/dltjm8FYYcXW+Z/XczrPGsoNc39Hn7DcSFaKiZRnUcFAECcCCp8EXYCAIBIVGeoBABAnGip8FWdR1WlXPsziz6qL6hj3y+nInNIacCwxaCZsW0OxW9/m7s6ubalBebSMEkIgydOeMpmRvCsXvmGZNJTnhkwh7g9VptT0dMz8TuZDE5hMLN+y97pPSifhSGiyJSe4lyawjkoDCn1RVABAIArWip8kVMBAAAiUZ2hEgAAcaKlwld1HhXy4jxNd5h5KfzKjY3S4GDeFQrKqbBTQdicimTS2/fb1DTRUGdTHLJOhsmpsLNMHDXlEVOebsozbeXNuQk61sycisHB3PkikrRggbds56kYGvY2WnonRFfw/9rmZJT4Vukonik7zwdBhS+6PwAAQCSqM1QCACBOjP7wRVCRQ7U167lP0x1yB0HdIY2N3scC2vDtYttlYYddJpNHzBa8wzpfeulNk24ri+kvGDCLj5uyPdXNprwoYEhp0LEeOjTx+8yZ4Gm57fNt94r9V2V1f1gl7t6I/Q67KFjUU3mX7fsu3R++6P4AAACRqM5QCQCAONFS4as6jwoAgDgRVPiqzqNCJAL72V1zKDKXp6fmHhz0Ttmdg91c0K3QszMdhjylEydaM7ZV713VXvAmCcHmVNhbn9sjmW2rZpMczMGdyT2iVa++mhz//frrkj22vr4ZOZ+f61/jyzWHwjXHIitJoiHnYkwdLjka3Jq99AgqAABwRUuFr+o8KgAA4sSQUl8EFQAAuKKlwldFHFXmbXZRxlxyLDJvd57OqQhg8wDsXAup1CnzjBOmPGTKE5kRZ87Myb1zszOz66wcC5sCYNcfNLdCbzQHN2xmvbbHKp3O+F0ne2yvvurNqbDPD51TUWaYtwIoD1x6AAC4oqXCV3UeFQAAcSKo8EWfAgAAiER1hkpTlGu3d+z90LlyLPxyKgIqFDQNhmQfeN2Uk6Y8sX7QrcPtCjY7wz49aLn9VzU6ztExscUzkmpljy3orvOhUyS4tXnJ2HthuOabud5Lg3y2STD6wxdBBQAAruj+8FWUEHTr1q1avHixmpqatHz5cv3sZz8rxm4BAKgqrp+nTz31lJYvX66mpiadf/75euCBB2KtX+xBxfbt27Vhwwbdfvvt2rt3ry699FJdffXV6unpiXvXKLbhYe9P0Y2Yn1HzM2R+JtYNrLpZwW552Py4Lg+SXb/0s9Jb8B57KjXq+QneHtLSQ9gZyo6c0i0VYX4cuX6e/uEPf9Cf//mf69JLL9XevXv1+c9/Xp/61Kf0ve99L+zRTyr2K+aLX/yibrzxRt10001asmSJtmzZovb2dt1///1x7xoAgHiUIKhw/Tx94IEHtHDhQm3ZskVLlizRTTfdpE984hO65557wh79pGLt1BkaGtKePXv0uc99zvN4R0eHdu3albX+4OCgBgcHx8sDA2NTCiWTSSWTNsmu+GyCU/LsV7xkkb7qBX1rCqrGyIjb+nZOqsSIeYLdYNAkVunkTEnJs38nMx7LYiqYSnlfA/XmHmDTptkDsvWx5Yn619V5t520x9bknY0qNW2ap2z/M0HRuq2pPQ/2WBsbvetPmzbi+Z15LGe36CnV13trZE+7fS1kHb/93waVR03rSNCLz1zfoylvBV0vsVwvxeHhpOd3ENfExmIrZqKm67krtnL4nHCV/pxLa2xsVKO94OX+eSpJzzzzjDo6OjyPXXnllfr617+uZDKpevsmGoFYg4pjx45pZGRE8+bN8zw+b9489WXfUlKdnZ268847sx7v7t6p6dOnx1bPsLq6u0tdhfI0Y0busqSu9vbJn//MMzk3/4lP5C4He36Sv6Udz5lVv/SlnFt6q+Oenw5cY4endPfd/mt94xvP+y/Q/znVJ+BUB7NTdtryoUMhdxC97u6uUlehYpXruTt9+nTwSlGJKFGz3bwH3nHHHdq8eXPW6q6fp5LU19fnu/7w8LCOHTumN77xjYXXfxJFST9NZH0LS2U9JkmbNm3Sxo0bx8sDAwNqb2/X6tUdam5ujr2eQfxaKrq6u3XF6tWqL0Imb9wtFfYQ7IinhhEzRPO4ubW4/eCw/XwZ6ycTCXW1t+uKgwdVn/5a+aY3edd/73s9xZ27z/WUt23zrt7VZW9A/j+mbL/FvG38r7/9W+/F9dV/NBfpBz7gKf7XSy95yr8yW7ZDSv/UlDtMefpXv+op75j9t56yfY/p6enVN76xT5/4xDK9/nr2kNJEYoGnvHq19/l/9Vfe8lVXecvn9h+wO/SW7RhV05KjlhZvec6c3MvNN7PRkLc+z3U5Dg8n1d3dpdWrr1BdXfY3tXJvmbCK3VKR69yVmv3WH6ewOTfp5x48eNDz+ebXSpEp38/TXOv7PR6VWD8J586dq9ra2qwo6siRI1nRkzR5s099fX0szTSuJrsY6+vqilK/oBdw0GskaLl9I7bl+oT5ULZRR03ABebTJl2fSk0EFQEVSiS859i2dL7+un052wO25Yn6Dw97t11vj818iCZe9wZY9pUR9LZta2rPgT3WjF5BSTobSIz9Hvvbu8egc5VVH/u/tsdvXzxBZftasNvL2qG3vqPmA8v1/S+fGL+uzv99haAiePuTnbtSK2adwiY5p5/b3Nyc15dm189TSWpra/Ndv66uTnNsoB+RWBM1GxoatHz5cnV1eZvKurq6dMkll8S5awAAqkYhn6erVq3KWn/nzp1asWJFbAFY7G32Gzdu1Jo1a7RixQqtWrVK27ZtU09Pj9atWxf3rgEAiEVULRUugj5PN23apEOHDulb3/qWJGndunX6yle+oo0bN+rmm2/WM888o69//et67LHHCq94gNiDiuuvv17Hjx/XXXfdpcOHD2vp0qXasWOHFi1aFPeupxzb5Bv0oo09DSRXf0q6PbuubqJbJOAA7GLbjS/ZB6aZsp0Wd2L97G3ZVb0rNNjFpmxPbdDyoH/G5MfadHZrtTnXt+XQ//ugvrIqnS2wHISdO4O5N6JRiqAi6PP08OHDnjkrFi9erB07dujv//7v9dWvflXz58/Xl7/8Zf2VTaqKUFGu/FtuuUW33HJLMXYFAEDVyvV5+vDDD2c99v73v8k5BGcAAB2/SURBVF/PPWeHs8WHrxMAADgqRUtFJaiIoCI9Ya5E011ZC2oCz2yD9+v+CGCb8M85x1tOJLzzYKRS3iGo2QM9JzKuA7s/zM7MrmVzt+37hV2/0SZJmQrYU2ePVZqe8bv+7M+EWbNyP9+5O8S1b63I6G1BsY2MhLsM7BD/asEnNAAAiATxPQAAjuj+8EdQAQCAI4IKfwQVmFRWP7W9CFxyKHw3KO/0zI7DKm3eQFubt3z4sJ0xzjut5LnnTuQh2G1lXfEmKcHmUMy2Tzdlu3nNnestm4MLOtZZs+rHfzc11evMGW9OhT0X9vmhcyrCloO2H7C4Wt+Qkc1lBtBKmw21GhFUAADgiJYKfwQVAAA4YvSHP4IKAAAc0VLhj6Aih2rrnwvql4596ma/ySAyHwuYLMIutmkJC7x3+9axY62ecjLp/X9mrm+3lcUkJdicCpu9Yb+E2JyLrB2acxV0rOm7xL/pTWN3MLV3Irc5Ffb5dt4K5/99iafpZl6K8lVt75tww6UJAIAjWir8EVQAAOCIoMIfQcUUFnuTd65bZaan5m5s9E7ZnclcdbbJ3jbxn3eet2y7BM6c8U4g++Y3T/yd1f1hr3jT/WGHiL7BlG0DcFb3h628OVdBx9rfP/Z74UIpmcyuru0KChpi2lAX0GQd9ZBS+i+qBt0dyMSVDQCAI1oq/BFUAADgiCGl/rihGAAAiAQtFRXE9l0G3Qa+6FMbu+ZUnDkz9pyIcioycyT82OPPXN9uKyinovFc723V5544kXPfM+2tzgOGlNpjtTkSr78+9nvhQv9vTEE5FVm3UrcJKK7jjcmRmFJqNDrlcyno/vDHOwEAAI4IKvzR/QEAACJBSwUAAI5oqfBXcUGFa14BJrhO053VZxr0BJd5K9I5FU1NEzkVltlf0K3ObU5FUDd/Zt5BVk6FzTGw+SHmCbMDciqyJtHIutd67sU2RyKdOX7++WOn0v5rgqbpDrzVe5Co56Uw+68x68d5nU/13IAgmeeHczWB0R/+Ki6oAACg1Gip8MfXfAAAEAlaKgAAcERLhb+KDyqizrGopD7DsMce+9QCufrVR0cnHsszp6JBQ55yW1uDp3zypPfpdi6GXHM52JwF7TMbs8dikhQSb3yjcgqaKMJUbvYse5t27/+2tnbsKeefP3b6AqbVCLz3h46ZHBLLdZ4K5q2IzVR+zysnBBX+6P4AAACR4OsEAACOaKnwV3VBxVRuygvbLBo4hDSIy7DCdPdHba1UM0k97bDOV1/1FNvaWnNWJ+t25kZml8D0M6/k3FeWoDnDg9a358b23Rw75imed573WKdNk/7f/xvr/kh3heTanT0XNScHvA8ETdNtFbm7I8rXdvrvaplquhqOoRIxpNQf3R8AACASVddSAQBA3Oj+8EdQAQCAI4IKfwQVVazs+lr9cipyCcip8A4olRYu8CYOtLV5e/eypiHPzCt44YB3oclpCJyi3E7jHbTcsjkVfX2e4uzzvM+fcf608ZyK+vo8ply3ORQ2Z8Tuv8zf8crutQ1AEkEFAADOaKnwR1ABAIAjRn/4I6gAAMARLRX+CCowwb7KXctx79/mAdicC5MX0GATC3LlaLz0kneZzamwOQeW6zwNAfNSZNXHqJk5c+x370uqqa3NPlbLHntQ2WLabZSIy5wkYacsR3i8UwAA4IiWCn8EFQAAOCKo8EdQMZXF3X2Ra3l6SOnIyMTfQU3wYZvoc3V/mCGczt0hdttB03AHdX/YIaj23La0jP3u6Rm7TWnQkFXLdRpu1+VhBY2RRcWii6K6caUCAOCIlgp/BBUAADhiSKk/2qEAAEAkaKmYSlxyHgopu+4vvU4i4b9+0O24Xcs2jyEzp8LmNNgcC7s8aHhrUA6A3Z5rPsisWWN5FX/841jZ5lQETRvuWnbN2QgSNqcDZWOq5kgMD0u1teGeX424cgEAcERQ4W9qhpgAACBytFQAAOCIlgp/BBWITiHzVGTmVARMu+081XTQ3BC5cipszkTQPBVBxx42P8Q+//TpsZyK3t6xc3nOOd7lthyUcxFUtor9jsi8FSWTmTOR/ntUNVM2lyKN0R/+uDIBAHA0PCzVhIirqrWlYmqHmgAAIDK0VFSzKIZ85lo/zBDVVGrs95kzk3d/5JpWW3Lr3ghaHtT9ETSEtNjdH8mktGSJ9PLLY+2os2blXj+oe8Sy3QthX0t0X5Stqd6NUShaKvxxZQMA4Iigwh8hKgAAiAQtFQAAOKKlwh9BBSa45ky4Pt8vpyJzXFWYIaGFlDPzKALWTb3+uqc8pNzse03diROecsI1J8NK5yQcP+5/u0TXabCDbrUeNp+GHIqyQQ5FNBhS6o9XFwAAiARfHwAAcJQ5b1+hz69GBBUAADgiqPBHUIH8RZlzkc6pyHwsaG6GoJwLlxwKWzbrJpNJT9nmUNgjHzVl26/YYMsmR6PW1i3ItGljv/v7x+ascL11ueu8GQCQB4IKAAAc0VLhj0RNAAAcpQddhfmJ04kTJ7RmzRq1tLSopaVFa9as0au29db4/ve/ryuvvFJz585VIpHQvn37nPdLUAEAgKP0kNJCf+IeUvqRj3xE+/bt05NPPqknn3xS+/bt05o1a3I+59SpU3rPe96jf/7nfy54v3R/IDpxz3MR9tbnOXIubA6F2VJWToXNoQjKqQjSZHIsErbu9l4dp05N/B4ays6ZsOtHfR8YAGXrN7/5jZ588kk9++yzWrlypSTpa1/7mlatWqX9+/frLW95i+/z0kHHgQMHCt43QQUAAI7CxuFxxvHPPPOMWlpaxgMKSXr3u9+tlpYW7dq1a9KgIgqxdX8cOHBAN954oxYvXqxp06bpggsu0B133KGhoaC5CAEAKG9R5VQMDAx4fgYHB0PXra+vT62trVmPt7a2qq+vL/T2c4mtpeK3v/2tRkdH9eCDD+rNb36z/vd//1c333yzTp06pXvuuSeu3aLShAnXXbtHcnSv2FoEDRl1rbVd3154dvu1QceWXj5Z1lfYabZRtWrMq63Spu229c93Wblqb2/3lO+44w5t3rzZd93NmzfrzjvvzLm93bt3S5ISPkNTUqmU7+NRii2ouOqqq3TVVVeNl88//3zt379f999/P0EFAKCiRdX9cfDgQTU3N48/3tjYOOlzbr31Vt1www05t3veeefp+eef18svv5y17OjRo5o3b15hFc5TUXMq+vv7NXv27EmXDw4Oepp+BgYGJI0l0dlEunKQPPuqSJbrt76getn046Bvs3Z9Wx4dzV1OT3glKXn2b89/1UbQ9haAtbXesp3gqcFMMWUvTpvMmJ5AStJwRt2k4JaLoMTtoO9Ldnv21T1q62qOJXn2WNO/VV/vXd+eG3vugr6tmPORVbb/26DXhmtLid2f6/Icyv66LTKXlorh4aTndynkao0o5udE2NEb6ec3Nzd7gopc5s6dq7lz5waut2rVKvX39+sXv/iF3vWud0mSfv7zn6u/v1+XXHJJwXXOR9GCit///ve67777dO+99066Tmdnp2/Tzs7ubk2fPj3O6oXS1d1d6ipUrK4ZMyYKmX9L0vz5xa1MBepav744OwqarbQCcd0Wrru7q9RV8HX69OlSV6EsLFmyRFdddZVuvvlmPfjgg5KkT37yk/rgBz/oSdK88MIL1dnZqeuuu06S9Morr6inp0e9vb2SpP3790uS2tra1NbWlte+E6mUW8ifb5/OihUrxsu9vb16//vfr/e///3613/910mf59dS0d7ermNHjuQdyRVTcnhYXd3dumL1atWX462do26psAlEQTkM/f3ecnoYpMZaKroGB3XF4KDGv2MfP+5dP6hsm/eOHHFaP5XxwWhTo+yQUteWCtsOYF8dph1CtsGz1g4JnTPHU0y2t6tr/Xpd8dWvqn5oSLJNmmZ92aQtu9yWW1pyl239bKuQXW5bSmxLTFDLihXieiv767aMlfu5GxgY0NzWVvX398f2mTEwMKCWlhZddFG/amsL38fIyICef74ltrq+8sor+tSnPqUf/vCHkqQPfehD+spXvqJZs2aNr5NIJPTQQw9p7dq1kqSHH35YH//4x7O2lSvPw3J+VeTbp5PW29uryy+/XKtWrdK2bdtyPq+xsdG3P6m+vl71tnm3jNTX1ZVn/YKauF0TdmyQYd/4bdl2X/jsr/7sjyT3JnZbHzuyKCAISmXMDWGDhLBvl7ZB2W7Plu2rp9a+YdtjOXus9UNDY0GFbfa15yZHV5SvoK6ooK6poK4q17IVwQda2V63FaBcz10x6zQ8HKoXLvbJr2bPnq1HHnkk5zq2TWHt2rXjAUahnK/MfPt0JOnQoUO6/PLLtXz5cj300EOqsW9EAABUoHIPKkoltvar3t5eXXbZZVq4cKHuueceHT16dHxZvn0zAACgcsQWVOzcuVMvvPCCXnjhBS1YsMCzzDGNA5UqV5N2+jWQ+VjYJvKgfnqzPJHRVFpnug+K3f1Ra7sb7LFMdmx1dWNdG67nImz3g1WE7gqgnNBS4S+2/oi1a9cqlUr5/gAAUMnK/YZipUKSAwAAiARtkshf2CZ0v+6P2tqJkQZBTfiuZTusMccQ2Hoz78KoaVEL6s6wgtY303Rl1zWonJ7TY8aMsUm/wp6rKP+3fmWgygwPZw+CcmEHZFULrnwAABwRVPij+wMAAESClgoAABzRUuGPoKKa2X7toGm7g/rB7fNdhxFmltNXVF3dRE5FjDkTvuUc56Px5ElPucEMOQ16P7DvNQk7019QzkTGVLq+5fS02S0tY8dhl9vtxZ1jEYScC1SZkZFwgUG1DoSk+wMAAESCrwsAADgaHna/fVKmam2pIKgAAMARQYU/goqpLGzORVCORT45FU1Nk+dUBOVMBN2qPUhmfey+TU5Fwuy71vVcBeUwBOVQ5MqpGBlxn+ei2PNaBGGab1QYggp/5FQAAIBIEP4DAOCIlgp/BBUoXJi7iKa7PxobJwZ72yZ628VguwCsMF0SprsjzHBU333Zsmt3xWTdIbNmjXV/BA0pDdsdwrTcgDGqVCrMZBPVOVEF3R8AACASfL0AAMDZyNmfMM+vPgQVAAA4I6jwQ1AxlbgOCQ27fdsvn2lkZGKddE6FrY/t93dl929ub+6UU+E6fNUlv0Ryz4E499yx37Nnj2V8ueZUlNut0i1yNICKxJULAIAzWir8EFQAAOBsVOFGcDD6AwAAYFK0VCB/YfvBM5enZ41pbJRqa6Opj+vU2Jl5FK7zUkSdU1FojsWcOfmtH7T9YudMABWP7g8/XPkAADgbVbjAoDq7PwgqAABwRkuFH4KKqcx1iKlrk7+V2cSeOaQ03+4Pu307DDTMME7X7o6w3R+u3SG2PGPG2O+WlrGuJNfujaiHkAZhCCkwJXAlAwDgjJYKPwQVAAA4Y0ipH4aUAgCASNBSgfzF0e8dJqfClm1ehM0LyDVs1OZI2HWtqHMqXHMsGhvHph2fNcs/p8I1R4JpuFGg0TL6blrcutD94YcrGwAAZwQVfsonxAQAABWNlgoAAJzRUuGHoAITop6XIh+1tRPbCerXt3kOrnkJueaiCDsvRZCocyxqasZyKmbMGPu71DkT5EhULJc8hPS6o6opq1yK0mBGTT9T/VUBAAAiwtcLAACcMU+FH4IKAACckVPhh6ACkytGjkVdXf7Ps3kBrvcqyfV81xyKsOcibM5C+tbxM2Z481LSwuZQuNY3CDkXJUPuQ1wIKvzwagMAAJHg6wMAAM5oqfBDUIH8xdEdktn9EbT9sGUrV/dHrnULEXV3SLr745xz/Kc5L/W02nR3oOoRVPih+wMAAESCrxMAADhLKdyw0FRUFSkrBBUAADij+8MPQQUKFybHIpWaeCzf/nfXnAsrzNTbxc6pCFqerk96OGnUORLkUFQshpCilHgnAADAGS0VfggqAABwRlDhh3YyAAAQCVoqEJ2gfnW/vAS/Kaaj2r/rNN6lVGgOQ1OT/3PJmZiyasyIBHIs4kJLhR/eKQAAcMZdSv0QVAAA4IyWCj8EFSgevyGl+a4fdn9ScHdILnEPKXV9fro+kw3JjXp/AJAH3jkAAHA2qnCtDXR/AAAASXR/+CMtGAAARIKWCpRWrmm6w95aPUwOheu+4mb3n85JKXRIbqmPB0XDENO4MPrDD+8sAAA4o/vDDyErAACIBEEFAADORiL4ic+JEye0Zs0atbS0qKWlRWvWrNGrr7466frJZFKf/exn9fa3v10zZszQ/Pnz9bGPfUy9vb1O+6X7A+WrkGm/XZ5fTabSsSIUm2NhkXORr/Lu/vjIRz6il156SU8++aQk6ZOf/KTWrFmjH/3oR77rnz59Ws8995z+8R//UX/2Z3+mEydOaMOGDfrQhz6kX/7yl3nvl3ciAACqyG9+8xs9+eSTevbZZ7Vy5UpJ0te+9jWtWrVK+/fv11ve8pas57S0tKirq8vz2H333ad3vetd6unp0cKFC/PaN0EFAADOopn8amBgwPNoY2OjGhsbQ2xXeuaZZ9TS0jIeUEjSu9/9brW0tGjXrl2+QYWf/v5+JRIJzZo1K+99E1SgcoVt8i+nu5RaQceWHlKaa0guUIBc3SPpZTUanXS9qLtPgrprCl03vGiGlLa3t3seveOOO7R58+YQ25X6+vrU2tqa9Xhra6v6+vry2saZM2f0uc99Th/5yEfU3Nyc9755NwIAwFk0ORUHDx70fGjnaqXYvHmz7rzzzpxb3b17tyQpkUhkLUulUr6PW8lkUjfccINGR0e1devWwPUzEVQAAFAizc3NebcE3HrrrbrhhhtyrnPeeefp+eef18svv5y17OjRo5o3b17O5yeTSX34wx/WH/7wB/3nf/6nUyuFVKSgYnBwUCtXrtSvfvUr7d27V8uWLSvGbgEAiEnxR3/MnTtXc+fODVxv1apV6u/v1y9+8Qu9613vkiT9/Oc/V39/vy655JJJn5cOKH73u9/pv/7rvzRnzhznOhYlqPjMZz6j+fPn61e/+lUxdgfkh1wEIHLFzWsopfIdUrpkyRJdddVVuvnmm/Xggw9KGhtS+sEPftCTpHnhhReqs7NT1113nYaHh/XXf/3Xeu655/Qf//EfGhkZGc+/mD17thoaGvLad+wDkn/84x9r586duueee+LeFQAAkPRv//Zvevvb366Ojg51dHTooosu0re//W3POvv371d/f78k6aWXXtIPf/hDvfTSS1q2bJne+MY3jv/s2rUr7/3G+lXt5Zdf1s0336zHH39c06dPD1x/cHBQg4OD4+X0UJtkMqlkMhlbPQuVPDt6IFnOowjKFOcuHM5f4Th3hSv3c1fcz4nybamQxloXHnnkkZzrpNKjyDSWi5FZLlRsQUUqldLatWu1bt06rVixQgcOHAh8Tmdnp29m687u7ryCklLp6u4udRUqFucuHM5f4Th3hSvXc3f69Oki7o27lPpxDiryHdKya9cuDQwMaNOmTXlve9OmTdq4ceN4eWBgQO3t7epYvdo5A7UYksPD6uru1hWrV6ue/nknnLtwOH+F49wVrtzPnZ1ICsXn/KrId0jL3XffrWeffTZrzO2KFSv00Y9+VN/85jeznjfZTGL19fWqr693rWrR1NfVlXX9yhnnLhzOX+E4d4Ur13NX3DpFM6NmtXEOKvId0vLlL39Zd99993i5t7dXV155pbZv3+6ZOhQAgMpT3jkVpRJb+5W9+cg555wjSbrgggu0YMGCuHYLAABKpPw6xQAAKHu0VPgpWlAR1XAVAABKj6DCDy0VAAA4I6jwE/uMmgAAYGqgpQIAAGdMfuWHoAIAAGfMU+GH7g8AABAJWioAAHBGoqYfggoAAJwRVPih+wMAAESClgoAAJwx+sMPQQUAAM7o/vBD9wcAAIgELRUAADijpcIPQQUAAM4IKvwQVAAA4IwZNf2QUwEAACJBSwUAAM4YUuqHoAIAAGfkVPih+wMAAESClgoAAJzRUuGHoAIAAGcEFX7o/gAAAJGgpQIAAGe0VPghqAAAwBmTX/mh+wMAAESClgoAAJwx+ZUfggoAAJyNKFxjPzkVAABAEkGFP4IKACgjoyFT3WqqtFkdlYGgAgAAZ7RU+CnroCKVSkmSBgYGSlwTf8lkUqdPn9bAwIDq6+tLXZ2KwrkLh/NXuHI/d+XcUlHu5y79WZH+7IjXkMIlWw5HVZGyUtZBxWuvvSZJal+0qMQ1AQBUitdee00tLS2xbLuhoUFtbW3q6+sOva22tjY1NDREUKvykUgVJ6QryOjoqHp7ezVz5kwlEolSVyfLwMCA2tvbdfDgQTU3N5e6OhWFcxcO569wnLvClfu5S6VSeu211zR//nzV1MQ3DdOZM2c0NDQUejsNDQ1qamqKoEblo6xbKmpqarRgwYJSVyNQc3NzWV5glYBzFw7nr3Ccu8KV87mLq4UiU1NTU9UFA1FhRk0AABAJggoAABCJ2s2bN28udSUqWW1trS677DLV1ZV1T1JZ4tyFw/krHOeucJw75FLWiZoAAKBy0P0BAAAiQVABAAAiQVABAAAiQVABAAAiQVARscHBQS1btkyJREL79u0rdXUqwoEDB3TjjTdq8eLFmjZtmi644ALdcccdkcxYV422bt2qxYsXq6mpScuXL9fPfvazUlepInR2duqd73ynZs6cqdbWVl177bXav39/qatVkTo7O5VIJLRhw4ZSVwVlhqAiYp/5zGc0f/78Ulejovz2t7/V6OioHnzwQf3f//2fvvSlL+mBBx7Q5z//+VJXrexs375dGzZs0O233669e/fq0ksv1dVXX62enp5SV63sPfXUU1q/fr2effZZdXV1aXh4WB0dHTp16lSpq1ZRdu/erW3btumiiy4qdVVQhhhSGqEf//jH2rhxo773ve/pbW97m/bu3atly5aVuloV6Qtf+ILuv/9+vfjii6WuSllZuXKlLr74Yt1///3jjy1ZskTXXnutOjs7S1izynP06FG1trbqqaee0vve975SV6cinDx5UhdffLG2bt2qu+++W8uWLdOWLVtKXS2UEVoqIvLyyy/r5ptv1re//W1Nnz691NWpeP39/Zo9e3apq1FWhoaGtGfPHnV0dHge7+jo0K5du0pUq8rV398vSbzOHKxfv17XXHONVq9eXeqqoEwxJVoEUqmU1q5dq3Xr1mnFihU6cOBAqatU0X7/+9/rvvvu07333lvqqpSVY8eOaWRkRPPmzfM8Pm/ePPX19ZWoVpUplUpp48aNeu9736ulS5eWujoV4Tvf+Y6ee+457d69u9RVQRmjpSKHzZs3K5FI5Pz55S9/qfvuu08DAwPatGlTqatcVvI9f5l6e3t11VVX6W/+5m900003lajm5S2RSHjKqVQq6zHkduutt+r555/XY489VuqqVISDBw/q05/+tB555BHuzomcyKnI4dixYzp27FjOdc477zzdcMMN+tGPfuR5Yx8ZGVFtba0++tGP6pvf/GbcVS1L+Z6/9JtUb2+vLr/8cq1cuVIPP/ywamqIeTMNDQ1p+vTp+u53v6vrrrtu/PFPf/rT2rdvn5566qkS1q5y3HbbbXr88cf19NNPa/HixaWuTkV4/PHHdd1116m2tnb8sZGRESUSCdXU1GhwcNCzDFMXQUUEenp6NDAwMF7u7e3VlVdeqX//93/XypUrtWDBghLWrjIcOnRIl19+uZYvX65HHnmEN6hJrFy5UsuXL9fWrVvHH3vrW9+qv/zLvyRRM0AqldJtt92mH/zgB/rpT3+qP/mTPyl1lSrGa6+9pj/+8Y+exz7+8Y/rwgsv1Gc/+1m6kDCOnIoILFy40FM+55xzJEkXXHABAUUeent7ddlll2nhwoW65557dPTo0fFlbW1tJaxZ+dm4caPWrFmjFStWaNWqVdq2bZt6enq0bt26Ulet7K1fv16PPvqonnjiCc2cOXM8D6WlpUXTpk0rce3K28yZM7MChxkzZmjOnDkEFPAgqEDJ7dy5Uy+88IJeeOGFrCCMhjSv66+/XsePH9ddd92lw4cPa+nSpdqxY4cWLVpU6qqVvfQw3Msuu8zz+EMPPaS1a9cWv0JAFaL7AwAARIJMOAAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEAmCCgAAEIn/D44HJdM+sSlrAAAAAElFTkSuQmCC", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "PyObject " - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "### wigner function \n", - "x_ls = [-5:0.1:5;]\n", - "wig = wigner(ρ_end_output, x_ls, x_ls)\n", - "\n", - "close(\"wigner\")\n", - "figure(\"wigner\")\n", - "v = maximum(real(wig))\n", - "pcolormesh(x_ls, x_ls, transpose(real(wig)), cmap = \"seismic\", vmin = -v, vmax = v)\n", - "grid(true)\n", - "colorbar()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 1.10", - "language": "julia", - "name": "julia-1.10" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.10.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/.other/backups/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4__bu.jl b/.other/backups/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4__bu.jl deleted file mode 100644 index 67e6fda..0000000 --- a/.other/backups/08-2_pulse-propagation-delay__PRA2026_113-013730_fig4__bu.jl +++ /dev/null @@ -1,175 +0,0 @@ -# # TODO - -# # Ramsey Interference with Delayed Fock Pulses - -# In this example, we reproduces the Ramsey-like interference pattern for a partially delayed input Fock state with `n = 9`, studied in [V. R. Christiansen and K. Mølmer, Phys. Rev. A 113, 013730 (2026)](https://journals.aps.org/pra/abstract/10.1103/3f3w-jmj8). -# We model a single input Fock pulse that is split on a 50/50 beam splitter (with vacuum padding on the second port), -# creating two channels that interact with the two-level system. We then scan the detuning to extract the excited-state -# population at the evaluation time used in the paper and compare with a coherent-state drive of the same mean photon number. - -using QuantumInputOutput -using SecondQuantizedAlgebra -using QuantumOptics -using LinearAlgebra -using PyPlot - -# - -## symbolic Hilbert space -hu = FockSpace(:u) -hd1 = FockSpace(:d1) -hd2 = FockSpace(:d2) -hs = NLevelSpace(:atom, 2) -h = hu ⊗ hd1 ⊗ hd2 ⊗ hs - -## symbolic operators -au = Destroy(h, :au, 1) -ad1 = Destroy(h, :ad_1, 2) -ad2 = Destroy(h, :ad_2, 3) -σ(i, j) = Transition(h, :σ, i, j, 4) - -## symbolic parameters -@rnumbers γ Δ r t -gu, gd1in, gd1out, gd2in, gd2out = cnumbers("gu gd1_{in} gd1_{out} gd2_{in} gd2_{out}") -nothing # hide - -# - -# Two-channel coupling to the atom with a beam splitter. -# The second input is a padding (vacuum) channel. - -G_u = concatenate(SLH(1, gu*au, 0), SLH(1, 0, 0)) - -S_bs = [r t; t -r] -G_bs = SLH(S_bs, [0, 0], 0) - -I2 = Matrix(I, 2, 2) -G_u_bs = concatenate(G_u ▷ G_bs, SLH(I2, [0, 0], 0)) - -I4 = Matrix(I, 4, 4) -G_d1_d2 = SLH(I4, [gd1in*ad1, gd2in*ad2, gd1out*ad1, gd2out*ad2], 0) # input at port 1 & 2, output at port 3 & 4 - -G_u_bs_d1_d2 = G_u_bs ▷ G_d1_d2 -nothing #hide - -# - -G_u_bs_d1_d2.hamiltonian - -L_atom = [0, 0, √(γ/2)*σ(1, 2), √(γ/2)*σ(1, 2)] -G_atom = SLH(I4, L_atom, Δ*σ(2, 2)) - -G_u_bs_d1_d2_atom = G_u_bs_d1_d2 ▷ G_atom -H = hamiltonian(G_u_bs_d1_d2_atom) -L = lindblad(G_u_bs_d1_d2_atom) - -# - -## Pulse parameters -n = 5#9 -γ_ = 1.0 -τ = 0.5/γ_ -tw = π^(3/2) / (8*γ_*n) -tp = 4*tw - -u(t) = 1/(√(tw)*π^(1/4)) * exp(-(t - tp)^2 / (2*tw^2)) -ud1(t) = u(t-tp) -ud2(t) = u(t-tp-τ) - -Tend = 2tp + τ + 2tw -dt = tw/30 -T = [0:dt:Tend;] -t1 = 2tp + τ + 2tw - -rn = 1/√(2) -tn = 1/√(2) - -gu_ = u_to_gu(u, T) -gd1in_ = v_to_gv(u, T) -gd1out_ = u_to_gu(ud1, T) -gd2in_ = v_to_gv(u, T) -gd2out_ = u_to_gu(ud2, T) -dict_p_t = - Dict([gu, gd1in, gd1out, gd2in, gd2out] .=> [gu_, gd1in_, gd1out_, gd2in_, gd2out_]) - -# - -## numerical bases -bu = FockBasis(n) -bd1 = FockBasis(n) -bd2 = FockBasis(n) -bs = NLevelBasis(2) -b = bu ⊗ bd1 ⊗ bd2 ⊗ bs - -σ22_QO = translate_qo(σ(2, 2), b) - -dict_p_Δ(Δn) = Dict([γ, Δ, r, t] .=> [γ_, Δn, rn, tn]) -H_QO_Δ(Δn) = translate_qo(H, b; parameter = dict_p_Δ(Δn), time_parameter = dict_p_t) -L_QO_Δ(Δn) = [ - translate_qo(L[i], b; parameter = dict_p_Δ(Δn), time_parameter = dict_p_t) for - i = 1:length(L) -] -nothing # hide -# - -ψ0_fock = fockstate(bu, n) ⊗ fockstate(bd1, 0) ⊗ fockstate(bd2, 0) ⊗ nlevelstate(bs, 1) - -# - -# Detuning scan and excited-state population at t1. - -Δ_ls = range(-20γ_, 20γ_, length = 80) -pop_fock = zeros(length(Δ_ls)) -pop_coh = zeros(length(Δ_ls)) -idx_t1 = findmin(abs.(T .- t1))[2] -using ProgressMeter -prog = Progress(length(Δ_ls)) - -for (it, Δn) in enumerate(Δ_ls) - Δn = Δ_ls[it] - - H_QO = H_QO_Δ(Δn) - L_QO = L_QO_Δ(Δn) - - input_output = - (t, ρ) -> ( - H_QO(t), - [L_QO[i](t) for i = 1:length(L_QO)], - [dagger(L_QO[i](t)) for i = 1:length(L_QO)], - ) - - t_, ρt = timeevolution.master_dynamic([T[1], T[end]], ψ0_fock, input_output) - # pop_fock[it] = real(expect(σ22_QO, ρt[idx_t1])) - pop_fock[it] = real(expect(σ22_QO, ρt[end])) - - # t_, ρt = timeevolution.master_dynamic(T, ψ0_coh, input_output) - # pop_coh[it] = real(expect(σ22_QO, ρt[idx_t1])) - next!(prog) -end -nothing # hide - -# - -pygui(true) -close("ramsey-population") # hide -figure("ramsey-population") -plot(Δ_ls, pop_fock, label = "Fock, n=$(n)") -# plot(Δ_ls, pop_coh, ls="--", label="coherent, ⟨n⟩=9") -xlabel("detuning Δ/γ") -ylabel(L"\langle \sigma^{22} \rangle (t_1)") -grid(true) -legend() -tight_layout() - -# - -# ## Package versions - -using InteractiveUtils -versioninfo() - -using Pkg -Pkg.status( - ["QuantumInputOutput", "SecondQuantizedAlgebra", "QuantumOptics", "PyPlot"], - mode = PKGMODE_MANIFEST, -) diff --git a/.other/backups/translate_fct_test.jl b/.other/backups/translate_fct_test.jl deleted file mode 100644 index 8572e0c..0000000 --- a/.other/backups/translate_fct_test.jl +++ /dev/null @@ -1,48 +0,0 @@ -using QuantumInputOutput -using SecondQuantizedAlgebra -using SymbolicUtils -using Symbolics -QIO = QuantumInputOutput -using BenchmarkTools - -@cnumbers g t -@variables gt2(..) # symbolic function placeholder - -expr = 3 * sqrt(2 * conj(g)) -# expr = 3 * sqrt(2 * g) -gt2_numeric(t::Real) = t>1 ? (7t + 1im) : 9 - -### works -time_parameter = Dict(g => gt2(t)) -expr_sub = substitute(expr, time_parameter) -f_ = build_function(expr_sub, t, gt2; expression = Val(true)) # works!! # TODO -result = f_(2.0, gt2_numeric) -3 * sqrt(2 * conj(7*2 + 1im)) -f_new_sym = t -> f_(t, gt2_numeric) -f_new_sym(2.0) -@benchmark f_new_sym(2.0) -### - -f = build_function(expr, t, g; expression = Val(true)) -f_new = t -> f(t, gt2_numeric(t)) -f_new(2.0) - -f_def(t) = 3 * sqrt(t * conj(gt2_numeric(t))) -f_def(2.0) - - -@benchmark f_new(2.0) - -@benchmark f_def(2.0) - - -#### -@rnumbers gg - -f2 = build_function(expr, t, g, gg; expression = Val(true)) -f_new2 = t -> f2(t, gt2_numeric(t), 0) -f_new2(2.0) - -@benchmark f_new2(2.0) - -time_parameter diff --git a/.other/xx-x_cat-state-generation__PRA2004_70-033604.jl b/.other/xx-x_cat-state-generation__PRA2004_70-033604.jl deleted file mode 100644 index 2e56f8d..0000000 --- a/.other/xx-x_cat-state-generation__PRA2004_70-033604.jl +++ /dev/null @@ -1,184 +0,0 @@ -# # Deterministic cat-state generation - -# [H. Ritsch, et al., Phys. Rev. A 70, 033804 (2004)](https://doi.org/10.1103%2FPhysRevA.70.033804) -# As usual, we start by loading the packages and specifying the system. - -using QuantumInputOutput -using SecondQuantizedAlgebra -using QuantumOptics -using QuantumCumulants -using LinearAlgebra -using PyPlot; -pygui(true) - -# - -@rnumbers κ g γ Δa Δc -@cnumbers η gv -Natoms = 2 - -hc = FockSpace(:cavity) -ha = NLevelSpace(:atom, 2) -hv = FockSpace(:output) -h = hc ⊗ ha ⊗ hv - -a = Destroy(h, :a, 1) # cavity -σ(i, j) = Transition(h, "σ", i, j, 2) # two-level atom -av = Destroy(h, :a_v, 3) # output cavity -nothing # hide - -# We couple a classical drive into the cavity through the left mirror $(\kappa_L)$. The decay through the right mirror can be added in several ways: with the `concatenate` rule, including it already in the initial cavity SLH triple or by simply including the decay term to the Lindblad by hand. In this example, we use the first option. - -H_ac = -Δc*a'a - Δa*σ(2, 2) - g*(σ(2, 1)*a + σ(1, 2)*a') + η*σ(2, 1) + η'*σ(1, 2) -J = [√(κ)*a, √(γ)*σ(1, 2)] - - -## numerical parameters -κ_ = 10.0 # 1.0 -γ_ = 0.0 -g_ = 100.0 -Δa_ = 0.0 -Δc_ = 0.0 - -p_sym = [κ, g, γ, Δa, Δc] -p_num = [κ_, g_, γ_, Δa_, Δc_] -dict_p = Dict(p_sym .=> p_num) - -# Gaussian pulse (definiton?) -η0 = 2g_# 9g_ -τ = 5/g_ -η_t(t) = η0*exp(-(t-4τ)^2 / (2*τ^2)) -Tend = 10τ -1 / κ_ - -### rectengular pulse -# η0 = √(8)*g_ -# T_pulse = 2π/g_ -# η_t(t) = (t [η_t, ηc_t]) -T = [0:0.005:1;]*Tend -ΔT = T[2] - T[1] - -## numerical basis -bc = FockBasis(16) -ba = NLevelBasis(2) -bv = FockBasis(16) -b = bc ⊗ ba ⊗ bv -# -a_QO = destroy(bc) ⊗ one(ba) -ad_QO = dagger(a_QO) -σ_QO(i, j) = one(bc) ⊗ transition(ba, i, j) - -ops_sym = [a, a', σ(2, 2), σ(1, 2), σ(2, 1)] -ops_QO = [a_QO, dagger(a_QO), σ_QO(2, 2), σ_QO(1, 2), σ_QO(2, 1)] -ops_dict = Dict(ops_sym .=> ops_QO) - -H_QO = - translate_qo(H_ac, b; parameter = dict_p, time_parameter = dict_t, operators = ops_dict) -L_QO = translate_qo(√(κ)*a, b; parameter = dict_p, operators = ops_dict) -J_add_QO = √(γ_)*σ_QO(1, 2) - -J = [L_QO, J_add_QO] -Jd = dagger.(J) - -function input_output(t, ρ) - H = H_QO(t) - return H, J, Jd -end - -ψ0 = fockstate(bc, 0) ⊗ nlevelstate(ba, 1) -t_, ρt = timeevolution.master_dynamic(T, ψ0, input_output) - -n_t = real(expect(ad_QO*a_QO, ρt)) -σ22_t = real(expect(σ_QO(2, 2), ρt)) -tr_ρa2 = tr.(ptrace.(ρt, 1) .^ 2) - -n_out = sum(n_t)*κ_*ΔT -@show n_out - -close("n(t)") -figure("n(t)") -subplot(311) -plot(t_*g_, n_t) -plot(T*g_, η_t.(T)/η0*maximum(n_t), ls = "--", color = "grey") -grid(true) -xlabel("gt") -ylabel("⟨a⁺a⟩") -subplot(312) -plot(t_*g_, σ22_t) -grid(true) -xlabel("gt") -ylabel("⟨σ²²⟩") -subplot(313) -plot(t_*g_, tr_ρa2) -grid(true) -xlabel("gt") -ylabel("tr(ρa²)") -tight_layout() - -Ls(t) = L_QO -g1_m = two_time_corr_matrix(T, ρt, input_output, Ls) # TODO: two_time_corr_matrix for Ls = const - -close("g1(t1,t2) matrix") # hide -figure("g1(t1,t2) matrix", figsize = (4.5, 3.5)) -pcolormesh(T, T, real.(g1_m), cmap = "inferno") -xlabel(L"\gamma t_2") -ylabel(L"\gamma t_1") -colorbar(label = L"g^{(1)}(t_1,t_2)") -tight_layout() - -F = eigen(g1_m) -n_avg = real.(F.values)*ΔT -modes = F.vectors -v1_mode = (modes[:, end]) / √(ΔT) - -single_mode = n_avg[end]/n_out -@show single_mode - -# time-dependent coupling for the output mode $v(t)$ -gv_t = v_to_gv(v1_mode, T) -gvc_t = t -> conj(gv_t(t)) -dict_t_2 = Dict([η, conj(η), gv, conj(gv)] .=> [η_t, ηc_t, gv_t, gvc_t]) - -# needed later # TODO: move down -G_ac = SLH(1, [√(κ)*a], H_ac) -G_v = SLH(1, [gv*av], 0) -G_cas = G_ac ▷ G_v - -H_2 = G_cas.hamiltonian -L_2 = G_cas.lindblad[1] - -H_QO_2 = translate_qo(H_2, b; parameter = dict_p, time_parameter = dict_t_2) -L_QO_2 = translate_qo(L_2, b; parameter = dict_p, time_parameter = dict_t_2) -J_add_QO_2 = translate_qo(√(γ)*σ(1, 2), b; parameter = dict_p) - -function input_output_2(t, ρ) - H = H_QO_2(t) - J = [L_QO_2(t); J_add_QO_2] - return H, J, dagger.(J) -end - -ψ0_2 = ψ0 ⊗ fockstate(bv, 0) -t_2, ρt_2 = timeevolution.master_dynamic(T, ψ0_2, input_output_2) - -av_QO_2 = translate_qo(av, b) -n_v1_t = real(expect(dagger(av_QO_2)*av_QO_2, ρt_2)) -n_v1_t[end] - -ρ_end_output = ptrace(ρt_2[end], [1, 2]) - -tr(ρ_end_output^2) - -### wigner function -x_ls = [-7:0.1:7;] -wig = wigner(ρ_end_output, x_ls, x_ls) - -close("wigner") -figure("wigner") -v = maximum(real(wig)) -pcolormesh(x_ls, x_ls, transpose(real(wig)), cmap = "seismic", vmin = -v, vmax = v) -grid(true) -colorbar() diff --git a/README.md b/README.md index d8fdee2..c9db489 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ It combines a symbolic layer for the SLH formalism based on [SecondQuantizedAlge ## Development status +[![Tests](https://github.com/ChristophHotter/QuantumInputOutput.jl/actions/workflows/Tests.yml/badge.svg)](https://github.com/ChristophHotter/QuantumInputOutput.jl/actions/workflows/Tests.yml) [![Documentation dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://christophhotter.github.io/QuantumInputOutput.jl/dev/) Note that **QuantumInputOutput.jl** is still at an early stage of development. From e023d842aae5f86835557714cf1b07088b81817b Mon Sep 17 00:00:00 2001 From: ChristophHotter Date: Thu, 16 Apr 2026 11:54:03 -0400 Subject: [PATCH 2/4] feedback doc --- README.md | 2 +- docs/src/index.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c9db489..13e8e18 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ It combines a symbolic layer for the SLH formalism based on [SecondQuantizedAlge ## Key Features -- SLH modeling with cascade (`▷`) and concatenate (`⊞`) rules +- SLH modeling with cascade (`▷`), concatenate (`⊞`), and feedback reduction rules - Symbolic-to-numeric translation (including time-dependent couplings) - Virtual-cavity tools for temporal input and output modes - Two-time correlation functions and output-mode extraction diff --git a/docs/src/index.md b/docs/src/index.md index d0f3627..714b9db 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -12,7 +12,7 @@ The typical workflow is: ## Key Features -- SLH modeling with cascade and concatenate rules +- SLH modeling with cascade, concatenate, and feedback reduction rules - Symbolic-to-numeric translation (including time-dependent couplings) - Utilities for pulse modes, virtual cavities, interaction picture and pulse delay - Two-time correlation functions and output-mode extraction From 816570daba102d5ea43739e86da81ffff948174c Mon Sep 17 00:00:00 2001 From: ChristophHotter Date: Thu, 16 Apr 2026 12:30:34 -0400 Subject: [PATCH 3/4] effective couplings docu --- TODOs.md | 6 +++--- docs/src/implementation.md | 16 +++++++++++++++- docs/src/theory.md | 38 +++++++++++++++++++++++++++++++++++++- 3 files changed, 55 insertions(+), 5 deletions(-) diff --git a/TODOs.md b/TODOs.md index c91095f..00d4a1d 100644 --- a/TODOs.md +++ b/TODOs.md @@ -1,12 +1,12 @@ -# MAIN TODO - LIST: +# TODOs - [ ] examples - - [ ] Multi-mode Dicke state superradiance (https://journals.aps.org/pra/abstract/10.1103/PhysRevA.103.033713) - [ ] SUPER example - [ ] pulse delay advanced example - [x] feedback reduction (see SLH paper) - [ ] cumulants correlation matrix modes - [ ] H_loop in example 09-1 is not simplified correctly on the docu (locally it is fine; pkg versions) + - [ ] Multi-mode Dicke state superradiance (https://journals.aps.org/pra/abstract/10.1103/PhysRevA.103.033713) - [ ] create more tests (cov +80%) - [x] simple full example @@ -28,7 +28,7 @@ ## Additional TODOs -- [ ] u_eff and v_eff equation (PRA 2020, appendix) theory, API, implementation +- [ ] u_eff and v_eff equation (PRA 2020, appendix) theory, API, implementation - [ ] rename translate_qo (to to_numerics ?) diff --git a/docs/src/implementation.md b/docs/src/implementation.md index df5b446..74060e6 100644 --- a/docs/src/implementation.md +++ b/docs/src/implementation.md @@ -84,7 +84,21 @@ gu_t = coupling_input(u, T) gv_t = coupling_output(u, T) ``` -For multiple input/output modes the distortion of the pulse due to the subsequent/preceding virtual cavities needs to be taken into account. The effective input mode ``u_i^{\mathrm{eff}}(t)`` and output mode ``v_i^{\mathrm{eff}}(t)`` for the virtual cavity `i` are constructed via [`effective_input_mode`](@ref) and [`effective_output_mode`](@ref). +For multiple input/output modes the distortion of the pulse due to the subsequent/preceding virtual cavities needs to be taken into account. The effective input mode ``u_i^{\mathrm{eff}}(t)`` and output mode ``v_i^{\mathrm{eff}}(t)`` for the virtual cavity `i` are constructed via [`effective_input_mode`](@ref) and [`effective_output_mode`](@ref). We first compute `u_i_eff` / `v_i_eff` and then pass them to [`coupling_input`](@ref) / [`coupling_output`](@ref). + +```julia +# Two input modes and two output modes on the same time grid T +u_modes = [u1_mode, u2_mode] +v_modes = [v1_mode, v2_mode] + +# Effective modes for the second virtual cavities: u_2^(1), v_2^(1) +u2_eff = effective_input_mode(u_modes, T, 2) # = u_2^eff = u_2^(2-1) +v2_eff = effective_output_mode(v_modes, T, 2) # = v_2^eff = v_2^(2-1) + +# Couplings from effective modes +gu2_eff = coupling_input(u2_eff, T) +gv2_eff = coupling_output(v2_eff, T) +``` ## Output modes and the correlation function diff --git a/docs/src/theory.md b/docs/src/theory.md index 9acb117..e1ba6c5 100644 --- a/docs/src/theory.md +++ b/docs/src/theory.md @@ -46,7 +46,43 @@ $v(t)$, the coupling g_v(t) = -\frac{v^*(t)}{\sqrt{\int_0^t dt' \,|v(t')|^2}} ``` -absorbs that mode into the virtual output cavity. These expressions make it possible to treat input and output pulses as **single oscillator modes** in a cascaded network. Note, that this formalism can be extended to multiple input and output modes with modified couplings for each additional mode, see e.g. [A. Kiilerich, et al., Phys. Rev. A 102, 023717 (2020)](https://doi.org/10.1103/PhysRevA.102.023717). +absorbs that mode into the virtual output cavity. These expressions make it possible to treat input and output pulses as **single oscillator modes** in a cascaded network. + +For multiple input and output modes, one first constructs effective modes +``u_i^{\mathrm{eff}}(t)`` and ``v_i^{\mathrm{eff}}(t)`` (which include distortions from +the other virtual cavities). In recursive form (for ``j Date: Thu, 16 Apr 2026 12:32:05 -0400 Subject: [PATCH 4/4] update TODO --- TODOs.md => TODO.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) rename TODOs.md => TODO.md (95%) diff --git a/TODOs.md b/TODO.md similarity index 95% rename from TODOs.md rename to TODO.md index 00d4a1d..c7f70f2 100644 --- a/TODOs.md +++ b/TODO.md @@ -23,12 +23,12 @@ - [ ] better method for u_eff and v_eff (Victor) - [] docu - - u_eff and v_eff theory - - development status + - [x] u_eff and v_eff theory + - [ ] development status ## Additional TODOs -- [ ] u_eff and v_eff equation (PRA 2020, appendix) theory, API, implementation +- [x] u_eff and v_eff equation (PRA 2020, appendix) theory, API, implementation - [ ] rename translate_qo (to to_numerics ?)