Multiple Waveguide with Different Length

[phantomlsh]

Hi,

I am wondering if it is possible to make multiple waveguides each has a different length in time.

bw = WaveguideBasis(2, 2, times)

Thank you very much!

[mabuni1998]

Hmmm, the code does not support this at the moment. Also, I'm not sure which situation this would be helpful in. Would it be to reduce the Hilbert space? I think one could always just make the waveguides have the same length but let one of them interact longer with the system. Could you provide an example of what you are thinking of using this feature with?

[phantomlsh]

Hi,

Since I am doing waveguide simulations for some of our experimental devices, it is sometimes interesting to understand how systems with multiple waveguides evolve. Those experimental devices would have waveguides with different lengths.

I am currently working around with a time-dependent Hamiltonian to delay the emission of a photon artificially, but it would be great to have that built-in. Not a super significant feature, just a suggestion!

Thank you very much!

[mabuni1998]

I am not sure I understand the experimental configuration? Due you have a beamsplitter where the input from two emitters are not arriving at the same time?

[phantomlsh]

Yes exactly. The beamsplitter is not placed exactly in the middle of the waveguide. I currently simulate it using a time-dependent Hamiltonian to simulate the time delay between the two emitters.

[mabuni1998]

I could help better if I could see a working example of what you are currently doing. I would imagine that this difference in length could also be implemented in a post-selective way, where one simply incorporated the delay in some overlap interval. But again this depends on the quantities that you are looking to calculate.

[phantomlsh]

Sorry for the late reply. We are trying to simulate a real experiment and fit the simulation to the experimental data. The setup is an HOM interference, as illustrated by this slide. In the real experiment, the two waveguides have different lengths, which cannot be ignored.

More interestingly, I would also like to know if we can include any dissipation/loss in the simulation.

Thank you very much!

[mabuni1998]

Hmmm, if I understand the above correctly, you have a beamsplitter not quite in the middle between the two atoms, and it reflects and transmits 50/50, which then connects the qubits. What I would do would be something like the following. Here I am again imagining that the conveyor belt wraps around, and the,s we place the emitters at a distance tau from eachother with the total conveyor belt having length 2*tau. Now I put a beam splitter, which "reflects" the photon from atom A by translating it to a time bin after atom B and transmits by simply letting it continue in the same bin. See the following sketch:

The beamsplitter is implemented by coupling two waveguide delays with each other. One that is delayed by tau/2 + tau_d, where tau_d is how much the beamsplitter is displaced from the middle (thus shortening one side and lengthening another part) and the other operator acting on 3*tau/2 (the part after atom B.

The following code is a rough implementation of the above where I imagine you can arrive at the simulations you show in the slide if you tweak the timescales, delays and so on.

using WaveguideQED
using QuantumOptics

tau = 7.5 #Delay time between the two atoms
dt = 0.1 #Time step for the simulation
times = 0:dt:2*tau+dt

NPhotons = 2
NWaveguides = 1

be = FockBasis(1)
bw = WaveguideBasis(NPhotons,NWaveguides,times)
w1 = identityoperator(be) ⊗ identityoperator(be) ⊗ destroy(bw,1)
wd1 = identityoperator(be) ⊗ identityoperator(be) ⊗create(bw,1)

tau_d = 1 #Difference in length between the two waveguides

#Place beasmplitter in the middle of the two atoms
delay_bs1 = tau/2
w1_bs = identityoperator(be) ⊗ identityoperator(be) ⊗ destroy(bw,1;delay=delay_bs1 ÷ dt)
wd1_bs = identityoperator(be) ⊗ identityoperator(be) ⊗create(bw,1;delay=delay_bs1÷dt)

#Place the first beamsplitter slightly off center
delay_bs2 = 3*tau/2 + tau_d
w2_bs = identityoperator(be) ⊗ identityoperator(be) ⊗destroy(bw,1;delay=delay_bs2÷dt)
wd2_bs = identityoperator(be) ⊗ identityoperator(be) ⊗create(bw,1;delay=delay_bs2÷dt)

#Atom operators
ie = identityoperator(be)
s  = destroy(be)
sd  = create(be)

n_atom1 = (create(be) * destroy(be)) ⊗ ie ⊗ identityoperator(bw)
n_atom2 = ie ⊗ (create(be) * destroy(be)) ⊗ identityoperator(bw)

wds1 = ie ⊗ (s ⊗ create(bw,1))
wsd1 = ie ⊗ (sd ⊗ destroy(bw,1))

delay_atom2 = tau
wds1_atom2 = s ⊗ (ie ⊗ create(bw,1;delay=delay_atom2÷dt+1))
wsd1_atom2 = sd ⊗ (ie ⊗ destroy(bw,1;delay=delay_atom2÷dt+1))


V = pi/4 #50/50 beamsplitter
γ = 1
H_bs_1 = V/dt*(wd1_bs * w2_bs + wd2_bs*w1_bs) #Beasmplitter taking photon from atom 1 into waveguide 2



function gamma_t(t, width, scale, translation, gap)
    # Shift t so that translation is effectively our "zero" reference
    tp = t - translation
    
    # 1) If we haven't reached the first pulse yet:
    if tp < 0
        return 0.0
    end
    
    # 2) If we are in the first pulse window [0, width]:
    if tp <= width
        # "Forward" version
        return sqrt(γ/dt) * 1.75 / (1 + exp(-(tp - width/2)*scale))
    end
    
    # Now we are beyond the first pulse end, so check for the gap
    if tp <= width + gap
        # Inside the gap, output is zero
        return 0.0
    end
    
    # 3) Beyond the gap, define a local time relative to the start of the mirrored pulse
    #    which begins at t = translation + width + gap
    t_mirrored = tp - (width + gap)
    # t_mirrored goes from 0 to width for the second (mirrored) pulse window
    
    if t_mirrored >= 0 && t_mirrored <= width
        # "Mirrored" version: note the positive sign in the exponent
        return sqrt(γ/dt) * 1.75 / (1 + exp((t_mirrored - width/2)*scale))
    else
        # Outside the mirrored pulse
        return 0.0
    end
end

## Define the time-dependent coupling strength for the two atoms
H_atom1 = TimeDependentSum((x->gamma_t(x,4,4,1,tau/2))=>(wds1 + wsd1))
H_atom2 = TimeDependentSum((x->gamma_t(x,4,4,1+tau_d,tau/2))=>(wds1_atom2 + wsd1_atom2))

H = H_atom1 + H_atom2  + H_bs_1

psi = (fockstate(be,1) ⊗ fockstate(be,1) ⊗ zerophoton(bw));

function fout(t,psi)
    return (expect(n_atom1,psi),expect(n_atom2,psi))
end

psi_out = timeevolution.schroedinger_dynamic(times,psi,H,fout=fout;d_discontinuities=times)

na_atom1 = [psi_out[2][i][1] for i in 1:length(psi_out[2])]
na_atom2 = [psi_out[2][i][2] for i in 1:length(psi_out[2])]

using PyPlot
pygui(true)
fig,ax = subplots(1,1)
ax.plot(times,na_atom1,"b-",label="Atom 1")
ax.plot(times,na_atom2,ls="-",color="darkorange",label="Atom 2")
ax.plot(times,gamma_t.(times,4,4,1,tau/2)./ max(gamma_t.(times,4,4,1,tau/2)...),"g-",alpha=0.5)
ax.plot(times,gamma_t.(times,4,4,1+tau_d,tau/2) ./ max(gamma_t.(times,4,4,1+tau_d,tau/2)...),"g-",alpha=0.5)

ax.legend()

In the end I get this plot, which is close but missing the small bump which I imagine one gets by tweaking the timedependent coupling: