Merge pull request #31 from mabuni1998/Fixing-Plots-in-Documentation

added RCParams in plots and installed matplolib in initial setup

Author: mabuni1998

.github/workflows/docs.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Install Julia dependencies
         env:
           PYTHON: ""
-        run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
+        run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate(); using PyPlot'
       - name: Build and deploy
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

docs/make.jl

@@ -19,7 +19,7 @@ authors = "Matias Bundgaard-Nielsen",
 pages = [
 "WaveguideQED.jl" => "index.md",
 "theoreticalbackground.md",
-"toturial.md",
+"tutorial.md",
 "detection.md",
 "multiplewaveguides.md",
 "Examples" => ["Scattering on two level system" => "example_lodahl.md"],

docs/src/detection.md

@@ -1,4 +1,4 @@
-# [Detection and Projections](@id BStoturial)
+# [Detection and Projections](@id BStutorial)
 A beamsplitter is a partly reflective partly transmitive mirror that splits up an incomming photon as depicted here.
 
 ![beamsplitter](./illustrations/single_beamsplitter.png)

docs/src/example_lodahl.md

@@ -81,8 +81,8 @@ For the single photon states we have to calculate the two time scattered distrib
 ψ1LeftScat = zeros(ComplexF64,(length(times),length(times)))
 ψ1RightScat = zeros(ComplexF64,(length(times),length(times)))
 ψ1LeftRightScat = zeros(ComplexF64,(length(times),length(times)))
-ψ1Right = OnePhotonView(ψScat1,[:,1],1)
-ψ1Left = OnePhotonView(ψScat1,[:,1],2)
+ψ1Right = OnePhotonView(ψScat1,[:,1],2)
+ψ1Left = OnePhotonView(ψScat1,[:,1],1)
 
 for i in eachindex(times)
     for j in eachindex(times)
@@ -97,9 +97,9 @@ nothing #hide
 Finall, this can be plotted and we note that this matches fig. 3 in Ref. ^[1]:
 
 ```@example lodahl
-using PyPlot #hide
+using PyPlot; #hide
 fig,axs = subplots(3,2,figsize=(9,17))
-plot_list = [ψ2LeftScat,ψ2RightScat,ψ2LeftRightScat,ψ1LeftScat,ψ1RightScat,ψ1LeftRightScat]
+plot_list = [ψ2RightScat,ψ2LeftScat,ψ2LeftRightScat,ψ1RightScat,ψ1LeftScat,ψ1LeftRightScat]
 for (i,ax) in enumerate(axs)
     plot_twophoton!(ax,plot_list[i],times)
 end

docs/src/multiplewaveguides.md

@@ -1,7 +1,7 @@
 # Multiple waveguides
 
 ## [Two Waveguides](@id twowaveguide)
-In the previous examples, we have only considered cases with a single waveguide. In this toturial, we show how to model a beamsplitter and an optical switch using two waveguides. A beamsplitter or a swap gate can be modelled using the Hamiltonian $H_I = V(w_1^\dagger w_2 + w_2^\dagger w_1)$ where V is some interaction strength that determines which interaction is moddeled (we will discuss this in detail later). $w_1$ and $w_2$ is the annihilation operators of the two waveguides. A sketch of the system can be seen here:
+In the previous examples, we have only considered cases with a single waveguide. In this tutorial, we show how to model a beamsplitter and an optical switch using two waveguides. A beamsplitter or a swap gate can be modelled using the Hamiltonian $H_I = V(w_1^\dagger w_2 + w_2^\dagger w_1)$ where V is some interaction strength that determines which interaction is moddeled (we will discuss this in detail later). $w_1$ and $w_2$ is the annihilation operators of the two waveguides. A sketch of the system can be seen here:
 
 ![Alt text](./illustrations/twowaveguide.png)
 
@@ -49,7 +49,7 @@ nothing #hide
 ``` 
 
 ## Beamsplitter
-Let's now treat the same example as in [Interference on Beamsplitter](@ref BStoturial). We consider the two waveguides in a identic single photon state and thus use the above defined `ψ_single_1_and_2`. The Hamiltonian governing a beamsplitter in the time binned formalism has $V= \pi/4$:
+Let's now treat the same example as in [Interference on Beamsplitter](@ref BStutorial). We consider the two waveguides in a identic single photon state and thus use the above defined `ψ_single_1_and_2`. The Hamiltonian governing a beamsplitter in the time binned formalism has $V= \pi/4$:
 
 ```@example multiple
 V = pi/4

docs/src/theoreticalbackground.md

@@ -92,7 +92,6 @@ The effect of the creation operator is to create a photon in timebin k and can b
 This is also seen if we plot the creation operator acting on the vacuum:
 
 ```@example theory
-using PyPlot
 ψ = wd*zerophoton(bw)
 viewed_state = OnePhotonView(ψ)
 fig,ax = subplots(1,1,figsize=(9,4.5))
@@ -143,6 +142,7 @@ We can define a twophoton basis and corresponding operator by:
 ```@example theory
 bw = WaveguideBasis(2,times)
 wd = create(bw)
+nothing #hide
 ```
 The creation operator can then be visualized by acting on a onephoton state with ones all over. This is seen in the following. Note that the state is visualized as a contour plot mirrored around the diagonal.
 
@@ -170,7 +170,6 @@ nothing #hide
 Here, we defined the two photon equivalent of our single photon gaussian state. When we visualize it, we now need two times, and we make a contour plot. This is easily done viewing the twophoton state: 
 
 ```@example theory
-using PyPlot
 viewed_state = TwoPhotonView(ψ)
 fig,ax = subplots(1,1,figsize=(4.5,4.5))
 plot_twophoton!(ax,viewed_state,times)

docs/src/toturial.md renamed to docs/src/tutorial.md

@@ -1,4 +1,4 @@
-# Toturials
+# Tutorials
 In this section, we show simple examples that illustrate how to use **WaveguideQED.jl** in combination with [`QuantumOptics.jl`](https://qojulia.org/)
 
 ## [Combining with QuantumOptics.jl](@id combining)
@@ -9,7 +9,7 @@ Basises, states, and operators defined in `WaveguideQED.jl` can be effortlesly c
 
 We start by defining the basis of the cavity and waveguide:
 
-```@example toturial
+```@example tutorial
 using WaveguideQED
 using QuantumOptics
 times = 0:0.1:10
@@ -20,7 +20,7 @@ nothing #hide
 
 Next we want to create the Hamiltonian for the system. The interaction between the waveguide and cavity is at timestep k given by[^1] $$H_k = i \hbar \sqrt{\gamma / \Delta t}( a^\dagger w_k - a w_k^\dagger)$$, where $$a$$     ($$a^\dagger$$) is the cavity annihilation (creation) operator, $$w_k$$($$w_k^\dagger$$) is the waveguide annihilation (creation) operator, $$\gamma$$ is the leakage rate of the cavity, and `\Delta t = times[2]-times[1]` is the width of the timebin. `WaveguideQED.jl` follows the same syntax as [`QuantumOptics.jl`](https://qojulia.org/) and operators are defined from a basis. Operators of different Hilbert spaces are then combined using ⊗ (``\otimes``):
 
-```@example toturial
+```@example tutorial
 a = destroy(bc)
 ad = create(bc)
 w = destroy(bw)
@@ -33,7 +33,7 @@ nothing #hide
 
 With this we can now simulate the scattering of a single photon with a gaussian wavefunction scattered on a cavity. We define the initial state as waveguide state as:
 
-```@example toturial
+```@example tutorial
 ξ(t,σ,t0) = sqrt(2/σ)* (log(2)/pi)^(1/4)*exp(-2*log(2)*(t-t0)^2/σ^2)
 σ,t0 = 1,5
 ψ_waveguide = onephoton(bw,ξ,times,σ,t0)
@@ -42,21 +42,21 @@ nothing #hide
 
 Assuming the cavity is empty the combined initial state is then:
 
-```@example toturial
+```@example tutorial
 ψ_in = fockstate(bc,0) ⊗ ψ_waveguide
 nothing #hide
 ```
 
 With the initial state we can then call the solver the get the wavefunction after the interaction with the cavity.
 
-```@example toturial
+```@example tutorial
 ψ_out = waveguide_evolution(times,ψ_in,H)
 nothing #hide
 ```
 
 Plotting the wavefunction and its norm square gives:
 
-```@example toturial
+```@example tutorial
 using PyPlot
 viewed_state = OnePhotonView(ψ_out)
 fig,ax = subplots(1,2,figsize=(9,4.5))
@@ -79,7 +79,7 @@ We see that the wavefunction has changed after the interaction with the cavity.
 
 In the previous example, only the state at the final timestep was shown. This shows the output wavefunction, but one might also be interested in intermediate states or expectation values. Expectation values can be outputtet from the solver by using the `fout` keyword. As an example, we can get the number of photons in the cavity as a function of time by:
 
-```@example toturial
+```@example tutorial
 n = (ad*a) ⊗ identityoperator(bw)
 function exp_na(time,psi)
     expect(n,psi)
@@ -90,7 +90,7 @@ nothing #hide
 
 If we also want to know the number of photons in the waveguide state as a function of time another operator to out expectation function as:
 
-```@example toturial
+```@example tutorial
 n = (ad*a) ⊗ identityoperator(bw)
 n_w = identityoperator(bc) ⊗ (create(bw)*destroy(bw))
 function exp_na_and_nw(time,psi)
@@ -104,7 +104,7 @@ Where `expect(n_w,psi)` calculates the expectation value of all times of the pul
 
 This can be plottet as:
 
-```@example toturial
+```@example tutorial
 fig,ax = subplots(1,1,figsize=(9,4.5))
 ax.plot(times,na,"b-",label="na")
 ax.plot(times,nw,"r-",label="nw")