API

Abstract base class for all systems defined in this library.

Currently there are the following concrete systems:

• Spin
• SpinCollection
• CavityMode
• CavitySpinCollection

A class representing a single spin.

A spin is defined by its position and its detuning to a main frequency.

Arguments

• position: A vector defining a point in R3.
• delta: Detuning.

A class representing a system consisting of many spins.

Arguments

• spins: Vector of spins.
• polarizations: Unit vectors defining the directions of the spins.
• gammas: Decay rates.

A class representing a single mode in a cavity.

Arguments

• cutoff: Number of included Fock states.
• delta=0 Detuning.
• eta=0: Pump strength.
• kappa=0: Decay rate.

A class representing a cavity coupled to many spins.

Arguments

• cavity: A CavityMode.
• spincollection: A SpinCollection.
• g: A vector defing the coupling strengths between the i-th spin and the cavity mode. Alternatively a single number can be given for identical coupling for all spins.

geometry.chain(a, N)

Positions of spins on a chain in x-direction.

The chain starts at the origin and continues into positive x-direction.

Arguments

• a: Spin-spin distance.
• N: Number of spins

geometry.triangle(a)

Positions of spins on a equilateral triangle in the xy-plane with edge length a.

The positions are: (0,0,0), (a,0,0), (a/2, h, 0)

geometry.rectangle(a, b; Nx=2, Ny=2)

Positions of spins on a rectangular lattice in the xy-plane.

The lattice starts at the origin and continues into positive x and y direction.

Arguments

• a: Spin-spin distance in x-direction.
• b: Spin-spin distance in y-direction.
• Nx=2: Number of spins into x direction.
• Ny=2: Number of spins into y direction.

geometry.square(a; Nx=2, Ny=2)

Positions of spins on a square lattice in the xy-plane with distance a.

The lattice starts at the origin and continues into positive x and y direction.

geometry.hexagonal(a; Nr=1)

Positions of spins on a hexagonal lattice in the xy-plane.

The hexagonal lattice consists of Nr rings.

geometry.box(a, b, c; Nx=2, Ny=2, Nz=2)

Positions of spins on a orthorhombic lattice.

The lattice starts at the origin and continues into positive x, y and z direction.

geometry.cube(a; Nx=2, Ny=2, Nz=2)

Positions of spins on a cubic lattice with edge length a.

The lattice starts at the origin and continues into positive x, y and z direction.

geometry.ring(a, N; distance = false)

Ring of N particles with radius a. If distance is set to true, then a gives the distance between particles and the radius is determined accordingly.

geometry.lhc1()

Geometry of the LHC-I light harvesting complex in the xy-plane centered around `z=0` with a mean interatomic distance of `1.0`. Positions `1` to `32` constitute the outer ring, while the inner ring comprises positions `33` to `38`.

geometry.lhc1_p()

Normalized polarization vectors in an LHC-I light harvesting complex. Entries `1` to `32` pertain to the outer ring, while entries `33` to `38` give the inner ring's dipole orientations.

Note: This function does not return a geometry, butrather te polarizations of dipoles in the LHC-I complex.

geometry.excitation_phases(k, pos)

Calculate the excitation phases created in a geometry by an incident plane wave with wave vector k.

Arguments:
* `k`: Wave vector of the incident plane wave.
* `pos`: List of atomic positions.

interaction.Omega(ri::Vector, rj::Vector, µi::Vector, µj::Vector, γi::Real=1, γj::Real=1)

Arguments:

• ri: Position of first spin
• rj: Position of second spin
• µi: Dipole orientation of first spin.
• µj: Dipole orientation of second spin.
• γi: Decay rate of first spin.
• γj: Decay rate of second spin.

Note that the dipole moments μi and μj are normalized internally. To account for dipole moments with different lengths you need to scale the decay rates γi and γj, respectively.

interaction.Gamma(ri::Vector, rj::Vector, µi::Vector, µj::Vector, γi::Real=1, γj::Real=1)

Arguments:

• ri: Position of first spin
• rj: Position of second spin
• µi: Dipole orientation of first spin.
• µj: Dipole orientation of second spin.
• γi: Decay rate of first spin.
• γj: Decay rate of second spin.

Note that the dipole moments μi and μj are normalized internally. To account for dipole moments with different lengths you need to scale the decay rates γi and γj, respectively.

interaction.GammaMatrix(S::SpinCollection)

Matrix of the collective decay rate for a given SpinCollection.

interaction.OmegaMatrix(S::SpinCollection)

Matrix of the dipole-dipole interaction for a given SpinCollection.

GreenTensor(r::Vector, k::Number=2π)

Calculate the Green's Tensor at position r for wave number k defined by

\[G = e^{ikr}\Big[\left(\frac{1}{kr} + \frac{i}{(kr)^2} - \frac{1}{(kr)^3}\right)*I - \textbf{r}\textbf{r}^T\left(\frac{1}{kr} + \frac{3i}{(kr)^2} - \frac{3}{(kr)^3}\right)\Big]\]

Choosing k=2π corresponds to the position r being given in units of the wavelength associated with the dipole transition.

Returns a 3×3 complex Matrix.

effective_interaction.triangle_orthogonal(a)

Effective Omega and Gamma for a equilateral triangle with edge length a.

The polarization axis is orthogonal to the triangle plane.

effective_interaction.square_orthogonal(a)

Effective Omega and Gamma for a square with edge length a.

The polarization axis is orthogonal to the square plane.

effective_interaction.rectangle_orthogonal(a, b)

Effective Omega and Gamma for a rectangle with edge lengths a and b.

The polarization axis is orthogonal to the rectangle plane.

effective_interaction.cube_orthogonal(a)

Effective Omega and Gamma for a cube with edge length a

The polarization axis is orthogonal to the xy faces.

effective_interaction.box_orthogonal(a, b, c)

Effective Omega and Gamma for a box with edge lengths a, b and c.

The polarization axis is orthogonal to the top face.

effective_interaction.chain(a, Θ, N)

Effective Omega and Gamma for an infinite chain.

The calculation is done by adding N spins left and N spins right of a central spin.

Arguments

• a: Spin-spin distance.
• θ: Angle between polarization axis and spin chain.
• N: Number of included spins.

effective_interaction.chain_orthogonal(a, N)

Effective Omega and Gamma for an infinite chain with orthogonal polarization axis.

The calculation is done by adding N spins left and N spins right of a central spin.

Arguments

• a: Spin-spin distance.
• N: Number of included spins.

effective_interaction.squarelattice_orthogonal(a, N)

Effective Omega and Gamma for a infinite square lattice.

The polarization axis is orthogonal to the square lattice plane and the calculation is done by creating a (2N+1)*(2N+1) square lattice and calculate the combined interaction for the central spin.

Arguments

• a: Spin-spin distance.
• N: Number of included spins.

effective_interaction.hexagonallattice_orthogonal(a, N)

Effective Omega and Gamma for a infinite hexagonal lattice.

The polarization axis is orthogonal to the square lattice plane and the calculation is done by creating hexagonal lattice consisting of N rings and calculate the combined interaction for the central spin.

Arguments

• a: Spin-spin distance.
• N: Number of included spins.

effective_interaction.cubiclattice_orthogonal(a, N)

Effective Omega and Gamma for a infinite cubic lattice.

The polarization axis is orthogonal to the top face of a unit cell and the calculation is done by creating a (2N+1)(2N+1)(2N+1) cubic lattice and calculate the combined interaction for the central spin.

Arguments

• a: Spin-spin distance.
• N: Number of included spins.

effective_interaction.tetragonallattice_orthogonal(a, b, N)

Effective Omega and Gamma for a infinite tetragonal lattice.

The polarization axis is orthogonal to the top face of a unit cell and the calculation is done by creating a (2N+1)(2N+1)(2N+1) tetragonal lattice and calculate the combined interaction for the central spin.

Arguments

• a: Spin-spin distance for bottom side square.
• b: Height of the unit cell.
• N: Number of included spins.

effective_interaction.hexagonallattice3d_orthogonal(a, b, N)

Effective Omega and Gamma for a infinite 3D hexagonal lattice.

The lattice consists of stacked planes of hexagonal lattices where the the polarization axis is orthogonal to the planes. The calculation is done by creating hexagonal lattices with N rings, stacking 2N+1 lattices of this kind above each other and calculating the combined interaction for the central spin.

Arguments

• a: Spin-spin distance for hexagons.
• b: Distance between planes of hexagonal lattices
• N: Number of included spins.

effective_interaction_rotated.square_orthogonal(a, Nδ)

Effective Omega and Gamma for a square.

The polarization axis is orthogonal to the square plane.

Arguments

• a: Edge length.
• Nδ: Phase shift (Number of atoms in 2π).

effective_interaction_rotated.cube_orthogonal(a, dϕ)

Effective Omega and Gamma for a cube.

The polarization axis is orthogonal to the xy faces.

Arguments

• a: edge length.
• dϕ: Phase shift.

effective_interaction_rotated.chain_orthogonal(a, N, dϕ)

Effective Omega and Gamma for an infinite chain.

The polarization axis is orthogonal to the chain and the calculation is done by adding N spins left and N spins right of a central spin.

Arguments

• a: Spin-spin distance.
• N: Number of included spins.
• dϕ: Phase shift between neighboring spins.

quantum.basis(x)

Get basis of the given System.

quantum.blochstate(phi, theta[, N=1])

Product state of N single spin Bloch states.

All spins have the same azimuthal angle phi and polar angle theta.

quantum.dim(state)

Number of spins described by this state.

quantum.Hamiltonian(S)

Hamiltonian of the given System.

quantum.JumpOperators(S)

Jump operators of the given system.

quantum.JumpOperators_diagonal(S)

Jump operators of the given system. (diagonalized)

Diagonalized means that the Gamma matrix is diagonalized and the jump operators are changed accordingly.

quantum.timeevolution_diagonal(T, S, state0[; fout])

Master equation time evolution. (diagonalized)

Diagonalized means that the Gamma matrix is diagonalized and the jump operators are changed accordingly.

Arguments

• T: Points of time for which output will be generated.
• S: System
• ρ₀: Initial density operator.
• fout (optional): Function with signature fout(t, state) that is called whenever output should be generated.

quantum.timeevolution(T, S, state0[; fout])

Master equation time evolution.

Diagonalized means that the Gamma matrix is diagonalized and the jump operators are changed accordingly.

Arguments

• T: Points of time for which output will be generated.
• S: System
• ρ₀: Initial density operator.
• fout (optional): Function with signature fout(t, state) that is called whenever output should be generated.

meanfield.rotate(axis, angles, state)

Rotations on the Bloch sphere for the given density operator.

Arguments

• axis: Rotation axis.
• angles: Rotation angle(s).
• ρ: Density operator that should be rotated.

quantum.squeeze(axis, χT, ρ₀)

Spin squeezing along an arbitrary axis.

Arguments

• axis: Squeezing axis.
• χT: Squeezing strength.
• ρ₀: Operator that should be squeezed.

quantum.squeezingparameter(ρ)

Calculate squeezing parameter for the given state.

independent.blochstate(phi, theta[, N=1])

Product state of N single spin Bloch states.

All spins have the same azimuthal angle phi and polar angle theta.

independent.dim(state)

Number of spins described by this state.

independent.splitstate(state)

Split state into sx, sy and sz parts.

independent.densityoperator(sx, sy, sz)
independent.densityoperator(state)

Create density operator from independent sigma expectation values.

independent.sx(state)

Sigma x expectation values of state.

independent.sy(state)

Sigma y expectation values of state.

independent.sz(state)

Sigma z expectation values of state.

independent.timeevolution(T, gamma, state0)

Independent time evolution.

Arguments

• T: Points of time for which output will be generated.
• gamma: Decay rate(s).
• state0: Initial state.

independent.timeevolution(T, S::SpinCollection, state0)

Independent time evolution.

Arguments

• T: Points of time for which output will be generated.
• S: SpinCollection describing the system.
• state0: Initial state.

Class describing a Meanfield state (Product state).

The data layout is [sx1 sx2 ... sy1 sy2 ... sz1 sz2 ...]

Arguments

• N: Number of spins.
• data: Vector of length 3*N.

meanfield.blochstate(phi, theta[, N=1])

Product state of N single spin Bloch states.

All spins have the same azimuthal angle phi and polar angle theta.

meanfield.dim(state)

Number of spins described by this state.

meanfield.splitstate(N, data)
meanfield.splitstate(state)

Split state into sx, sy and sz parts.

meanfield.densityoperator(sx, sy, sz)
meanfield.densityoperator(state)

Create density operator from independent sigma expectation values.

mpc.densityoperator(state)

Create density operator from MPCState.

meanfield.sx(state)

Sigma x expectation values of state.

meanfield.sy(state)

Sigma y expectation values of state.

meanfield.sz(state)

Sigma z expectation values of state.

meanfield.timeevolution(T, S::SpinCollection, state0[; fout])

Meanfield time evolution.

Arguments

• T: Points of time for which output will be generated.
• S: SpinCollection describing the system.
• state0: Initial ProductState.
• fout (optional): Function with signature fout(t, state) that is called whenever output should be generated.

meanfield.timeevolution_symmetric(T, state0, Ωeff, Γeff[; γ, δ0, fout])

Symmetric meanfield time evolution.

Arguments

• T: Points of time for which output will be generated.
• state0: Initial ProductState.
• Ωeff: Effective dipole-dipole interaction.
• Γeff: Effective collective decay rate.
• γ=1: Single spin decay rate.
• δ0=0: Phase shift for rotated symmetric meanfield time evolution.
• fout (optional): Function with signature fout(t, state) that is called whenever output should be generated.

meanfield.rotate(axis, angles, state)

Rotations on the Bloch sphere for the given ProductState.

Arguments

• axis: Rotation axis.
• angles: Rotation angle(s).
• state: ProductState that should be rotated.

Class describing a MPC state (Product state + Correlations).

The data layout is vector that in matrix form looks like

Cxx Cxy Cyy Cxz Czz Cyz

where the Cij are the appropriate correlation matrices. The expectation values sx, sy and sz are the diagonals of the matrices Cxx, Cyy and Czz, respectively.

Arguments

• N: Number of spins.
• data: Vector of length (3N)(2*N+1).

mpc.blochstate(phi, theta[, N=1])

Product state of N single spin Bloch states.

All spins have the same azimuthal angle phi and polar angle theta.

mpc.dim(state)

Number of spins described by this state.

mpc.splitstate(N, data)
mpc.splitstate(state)

Returns sx, sy, sz, Cxx, Cyy, Czz, Cxy, Cxz, Cyz.

mpc.correlation2covariance(corstate)

Convert a MPCState from correlation form into covariance form.

Basically it just calculates Covab = <sa sb> - <sa> <s_b>.

mpc.covariance2correlation(covstate)

Convert a MPCState from covariance form into correlation form.

Basically it just calculates <sa sb> = Covab + <sa> <s_b>.

mpc.densityoperator(state)

Create density operator from MPCState.

mpc.sx(state)

Sigma x expectation values of state.

mpc.sy(state)

Sigma y expectation values of state.

mpc.sz(state)

Sigma z expectation values of state.

mpc.Cxx(state)

Sigmax-Sigmax correlation values of MPCState.

mpc.Cyy(state)

Sigmay-Sigmay correlation values of MPCState.

mpc.Czz(state)

Sigmaz-Sigmaz correlation values of MPCState.

mpc.Cxy(state)

Sigmax-Sigmay correlation values of MPCState.

mpc.Cxz(state)

Sigmax-Sigmaz correlation values of MPCState.

mpc.Cyz(state)

Sigmay-Sigmaz correlation values of MPCState.

mpc.timeevolution(T, S::SpinCollection, state0[; fout])

MPC time evolution.

Arguments

• T: Points of time for which output will be generated.
• S: SpinCollection describing the system.
• state0: Initial MPCState.
• fout (optional): Function with signature fout(t, state) that is called whenever output should be generated.

mpc.rotate(axis, angles, state)

Rotations on the Bloch sphere for the given MPCState.

Arguments

• axis: Rotation axis.
• angles: Rotation angle(s).
• state: MPCState that should be rotated.

mpc.var_Sx(state0)

Variance of the total Sx operator for the given MPCState.

mpc.var_Sy(state)

Variance of the total Sy operator for the given MPCState.

mpc.var_Sz(state)

Variance of the total Sz operator for the given MPCState.

mpc.squeeze(axis, χT, state0)

Spin squeezing along an arbitrary axis.

Arguments

• axis: Squeezing axis.
• χT: Squeezing strength.
• state0: MPCState that should be squeezed.

mpc.squeezing_parameter(state)

Calculate squeezing parameter for the given state.

ReducedSpinBasis(N, M)

Basis for a system of N spin 1/2 systems, up to the M'th excitation.

reducedspintransition(b::ReducedSpinBasis, to::Vector{Int}, from::Vector{Int})

Transition operator $|\mathrm{to}⟩⟨\mathrm{from}|$, where to and from are given as vectors denoting the excitations.

reducedsigmap(b::ReducedSpinBasis, j::Int)

Sigma Plus Operator for the j-th particle.

reducedsigmam(b::ReducedSpinBasis, j::Int)

Sigma Minus Operator for the j-th particle.

reducedsigmax(b::ReducedSpinBasis, j::Int)

Sigma-X Operator for the j-th particle.

reducedsigmay(b::ReducedSpinBasis, j::Int)

Sigma-Y Operator for the j-th particle.

reducedsigmaz(b::ReducedSpinBasis, j::Int)

Sigma-Z Operator for the j-th particle.

reducedsigmapsigmam(b::ReducedSpinBasis, i, j)

Create the operator product σᵢ⁺σⱼ⁻ directly on a ReducedSpinBasis. Useful especially for a basis where only one excitation is included, since then the single operators are zero (do not conserve excitation number), but the product is not.

reducedspinstate(b::ReducedSpinBasis, inds::Vector{Int})

State where the excitations are placed in the atoms given by inds. Note, that b.MS <= length(inds) <= b.M must be satisfied.

Examples

julia> b = CollectiveSpins.ReducedSpinBasis(4,2)
ReducedSpin(N=4, M=2, MS=0)

julia> GS = CollectiveSpins.reducedspinstate(b,[]) # get the ground state
Ket(dim=11)
  basis: ReducedSpin(N=4, M=2, MS=0)
 1.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im

julia> ψ2 = CollectiveSpins.reducedspinstate(b,[1,2]) # First and second atom excited
Ket(dim=11)
  basis: ReducedSpin(N=4, M=2, MS=0)
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 1.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im
 0.0 + 0.0im

Omega_k_chain(k, a, polarization)

Collective frequency shift Omega_k of mode k for an infinite chain of atoms along x-axis.

WLOG, this calculation scales natural atomic frequency wavelength lambda0=1 and decay rate gamma0=1.

Arguments

• k: x-axis quasimomentum of collective mode in first BZ such that |k|<= pi/a.
• a: Atomic lattice spacing.
• polarization: 3D, complex vector of atomic polarization.

Gamma_k_chain(k, a, polarization)

Collective decay rate Gamma_k of mode k for an infinite chain of atoms along x-axis.

WLOG, this calculation scales natural atomic frequency wavelength lambda0=1 and decay rate gamma0=1.

Arguments

• k: x-axis quasimomentum of collective mode in first BZ such that |k|<= pi/a.
• a: Atomic lattice spacing.
• polarization: 3D, complex vector of atomic polarization.

Omega_k_2D(k_vec, a_vec1, a_vec2, polarization)

Collective frequency shift Omegak of in-plane mode kvec for an 2D array of atoms in yz-plane.

WLOG, this calculation scales natural atomic frequency wavelength lambda0=1 and decay rate gamma0=1.

Arguments

• k_vec: yz-axis quasimomentum of collective mode in first BZ such that |k|<= pi/a.
• a_vec1, a_vec2: 2D Bravais lattice vectors.
• polarization: 3D, complex vector of atomic polarization.
• Lambda: Cutoff frequency of renormalization.
• N1: Number of terms in a_vec1 reciprocal lattice direction.
• N2: Number of terms in a_vec2 reciprocal lattice direction.

Gamma_k_2D(k_vec, a_vec1, a_vec2, polarization)

Collective decay rate Gammak of in-plane mode kvec for an 2D array of atoms in yz-plane.

WLOG, this calculation scales natural atomic frequency wavelength lambda0=1 and decay rate gamma0=1.

Arguments

• k_vec: yz-axis quasimomentum of collective mode in first BZ such that |k|<= pi/a.
• a_vec1, a_vec2: 2D Bravais lattice vectors.
• polarization: 3D, complex vector of atomic polarization.