API
System
CollectiveSpins.System
— TypeAbstract base class for all systems defined in this library.
Currently there are the following concrete systems:
- Spin
- SpinCollection
- CavityMode
- CavitySpinCollection
CollectiveSpins.Spin
— TypeA 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.
CollectiveSpins.SpinCollection
— TypeA 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.
CollectiveSpins.CavityMode
— TypeA 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.
CollectiveSpins.CavitySpinCollection
— TypeA 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
CollectiveSpins.geometry.chain
— Functiongeometry.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
CollectiveSpins.geometry.triangle
— Functiongeometry.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)
CollectiveSpins.geometry.rectangle
— Functiongeometry.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.
CollectiveSpins.geometry.square
— Functiongeometry.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.
CollectiveSpins.geometry.hexagonal
— Functiongeometry.hexagonal(a; Nr=1)
Positions of spins on a hexagonal lattice in the xy-plane.
The hexagonal lattice consists of Nr
rings.
CollectiveSpins.geometry.box
— Functiongeometry.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.
CollectiveSpins.geometry.cube
— Functiongeometry.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.
CollectiveSpins.geometry.ring
— Functiongeometry.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.
CollectiveSpins.geometry.lhc1
— Functiongeometry.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`.
CollectiveSpins.geometry.lhc1_p
— Functiongeometry.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.
CollectiveSpins.geometry.excitation_phases
— Functiongeometry.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.
Dipole-Dipole Interaction
CollectiveSpins.interaction.Omega
— Functioninteraction.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.
CollectiveSpins.interaction.Gamma
— Functioninteraction.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.
CollectiveSpins.interaction.GammaMatrix
— Functioninteraction.GammaMatrix(S::SpinCollection)
Matrix of the collective decay rate for a given SpinCollection.
CollectiveSpins.interaction.OmegaMatrix
— Functioninteraction.OmegaMatrix(S::SpinCollection)
Matrix of the dipole-dipole interaction for a given SpinCollection.
CollectiveSpins.interaction.GreenTensor
— FunctionGreenTensor(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 Interactions
CollectiveSpins.effective_interaction.triangle_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.square_orthogonal
— Functioneffective_interaction.square_orthogonal(a)
Effective Omega and Gamma for a square with edge length a
.
The polarization axis is orthogonal to the square plane.
CollectiveSpins.effective_interaction.rectangle_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.cube_orthogonal
— Functioneffective_interaction.cube_orthogonal(a)
Effective Omega and Gamma for a cube with edge length a
The polarization axis is orthogonal to the xy faces.
CollectiveSpins.effective_interaction.box_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.chain
— Functioneffective_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.
CollectiveSpins.effective_interaction.chain_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.squarelattice_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.hexagonallattice_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.cubiclattice_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.tetragonallattice_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction.hexagonallattice3d_orthogonal
— Functioneffective_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 latticesN
: Number of included spins.
Rotated effective interactions
CollectiveSpins.effective_interaction_rotated.square_orthogonal
— Functioneffective_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π).
CollectiveSpins.effective_interaction_rotated.cube_orthogonal
— Functioneffective_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.
CollectiveSpins.effective_interaction_rotated.chain_orthogonal
— Functioneffective_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.
Methods
Quantum
CollectiveSpins.quantum.basis
— Functionquantum.basis(x)
Get basis of the given System.
CollectiveSpins.quantum.blochstate
— Functionquantum.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
.
CollectiveSpins.quantum.dim
— Functionquantum.dim(state)
Number of spins described by this state.
CollectiveSpins.quantum.Hamiltonian
— Functionquantum.Hamiltonian(S)
Hamiltonian of the given System.
CollectiveSpins.quantum.JumpOperators
— Functionquantum.JumpOperators(S)
Jump operators of the given system.
CollectiveSpins.quantum.JumpOperators_diagonal
— Functionquantum.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.
CollectiveSpins.quantum.timeevolution_diagonal
— Functionquantum.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.
CollectiveSpins.quantum.timeevolution
— Functionquantum.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.
CollectiveSpins.quantum.rotate
— Functionmeanfield.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.
CollectiveSpins.quantum.squeeze
— Functionquantum.squeeze(axis, χT, ρ₀)
Spin squeezing along an arbitrary axis.
Arguments
axis
: Squeezing axis.χT
: Squeezing strength.ρ₀
: Operator that should be squeezed.
CollectiveSpins.quantum.squeezingparameter
— Functionquantum.squeezingparameter(ρ)
Calculate squeezing parameter for the given state.
0th order: Independent spins
CollectiveSpins.independent.blochstate
— Functionindependent.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
.
CollectiveSpins.independent.dim
— Functionindependent.dim(state)
Number of spins described by this state.
CollectiveSpins.independent.splitstate
— Functionindependent.splitstate(state)
Split state into sx, sy and sz parts.
CollectiveSpins.independent.densityoperator
— Functionindependent.densityoperator(sx, sy, sz)
independent.densityoperator(state)
Create density operator from independent sigma expectation values.
CollectiveSpins.independent.sx
— Functionindependent.sx(state)
Sigma x expectation values of state.
CollectiveSpins.independent.sy
— Functionindependent.sy(state)
Sigma y expectation values of state.
CollectiveSpins.independent.sz
— Functionindependent.sz(state)
Sigma z expectation values of state.
CollectiveSpins.independent.timeevolution
— Functionindependent.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.
1st order: Meanfield
CollectiveSpins.meanfield.ProductState
— TypeClass 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.
CollectiveSpins.meanfield.blochstate
— Functionmeanfield.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
.
CollectiveSpins.meanfield.dim
— Functionmeanfield.dim(state)
Number of spins described by this state.
CollectiveSpins.meanfield.splitstate
— Functionmeanfield.splitstate(N, data)
meanfield.splitstate(state)
Split state into sx, sy and sz parts.
CollectiveSpins.meanfield.densityoperator
— Functionmeanfield.densityoperator(sx, sy, sz)
meanfield.densityoperator(state)
Create density operator from independent sigma expectation values.
mpc.densityoperator(state)
Create density operator from MPCState.
CollectiveSpins.meanfield.sx
— Functionmeanfield.sx(state)
Sigma x expectation values of state.
CollectiveSpins.meanfield.sy
— Functionmeanfield.sy(state)
Sigma y expectation values of state.
CollectiveSpins.meanfield.sz
— Functionmeanfield.sz(state)
Sigma z expectation values of state.
CollectiveSpins.meanfield.timeevolution
— Functionmeanfield.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 signaturefout(t, state)
that is called whenever output should be generated.
CollectiveSpins.meanfield.timeevolution_symmetric
— Functionmeanfield.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 signaturefout(t, state)
that is called whenever output should be generated.
CollectiveSpins.meanfield.rotate
— Functionmeanfield.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.
2nd order: Meanfield plus Correlations (MPC)
CollectiveSpins.mpc.MPCState
— TypeClass 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).
CollectiveSpins.mpc.blochstate
— Functionmpc.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
.
CollectiveSpins.mpc.dim
— Functionmpc.dim(state)
Number of spins described by this state.
CollectiveSpins.mpc.splitstate
— Functionmpc.splitstate(N, data)
mpc.splitstate(state)
Returns sx, sy, sz, Cxx, Cyy, Czz, Cxy, Cxz, Cyz.
CollectiveSpins.mpc.correlation2covariance
— Functionmpc.correlation2covariance(corstate)
Convert a MPCState from correlation form into covariance form.
Basically it just calculates Covab = <sa sb> - <sa> <s_b>.
CollectiveSpins.mpc.covariance2correlation
— Functionmpc.covariance2correlation(covstate)
Convert a MPCState from covariance form into correlation form.
Basically it just calculates <sa sb> = Covab + <sa> <s_b>.
CollectiveSpins.meanfield.densityoperator
— Methodmpc.densityoperator(state)
Create density operator from MPCState.
CollectiveSpins.mpc.sx
— Functionmpc.sx(state)
Sigma x expectation values of state.
CollectiveSpins.mpc.sy
— Functionmpc.sy(state)
Sigma y expectation values of state.
CollectiveSpins.mpc.sz
— Functionmpc.sz(state)
Sigma z expectation values of state.
CollectiveSpins.mpc.Cxx
— Functionmpc.Cxx(state)
Sigmax-Sigmax correlation values of MPCState.
CollectiveSpins.mpc.Cyy
— Functionmpc.Cyy(state)
Sigmay-Sigmay correlation values of MPCState.
CollectiveSpins.mpc.Czz
— Functionmpc.Czz(state)
Sigmaz-Sigmaz correlation values of MPCState.
CollectiveSpins.mpc.Cxy
— Functionmpc.Cxy(state)
Sigmax-Sigmay correlation values of MPCState.
CollectiveSpins.mpc.Cxz
— Functionmpc.Cxz(state)
Sigmax-Sigmaz correlation values of MPCState.
CollectiveSpins.mpc.Cyz
— Functionmpc.Cyz(state)
Sigmay-Sigmaz correlation values of MPCState.
CollectiveSpins.mpc.timeevolution
— Functionmpc.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.
CollectiveSpins.mpc.rotate
— Functionmpc.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.
CollectiveSpins.mpc.var_Sx
— Functionmpc.var_Sx(state0)
Variance of the total Sx operator for the given MPCState.
CollectiveSpins.mpc.var_Sy
— Functionmpc.var_Sy(state)
Variance of the total Sy operator for the given MPCState.
CollectiveSpins.mpc.var_Sz
— Functionmpc.var_Sz(state)
Variance of the total Sz operator for the given MPCState.
CollectiveSpins.mpc.squeeze
— Functionmpc.squeeze(axis, χT, state0)
Spin squeezing along an arbitrary axis.
Arguments
axis
: Squeezing axis.χT
: Squeezing strength.state0
: MPCState that should be squeezed.
CollectiveSpins.mpc.squeezingparameter
— Functionmpc.squeezing_parameter(state)
Calculate squeezing parameter for the given state
.
Reduced Spin
CollectiveSpins.reducedspin.ReducedSpinBasis
— TypeReducedSpinBasis(N, M)
Basis for a system of N spin 1/2 systems, up to the M'th excitation.
CollectiveSpins.reducedspin.reducedspintransition
— Functionreducedspintransition(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.
CollectiveSpins.reducedspin.reducedsigmap
— Functionreducedsigmap(b::ReducedSpinBasis, j::Int)
Sigma Plus Operator for the j-th particle.
CollectiveSpins.reducedspin.reducedsigmam
— Functionreducedsigmam(b::ReducedSpinBasis, j::Int)
Sigma Minus Operator for the j-th particle.
CollectiveSpins.reducedspin.reducedsigmax
— Functionreducedsigmax(b::ReducedSpinBasis, j::Int)
Sigma-X Operator for the j-th particle.
CollectiveSpins.reducedspin.reducedsigmay
— Functionreducedsigmay(b::ReducedSpinBasis, j::Int)
Sigma-Y Operator for the j-th particle.
CollectiveSpins.reducedspin.reducedsigmaz
— Functionreducedsigmaz(b::ReducedSpinBasis, j::Int)
Sigma-Z Operator for the j-th particle.
CollectiveSpins.reducedspin.reducedsigmapsigmam
— Functionreducedsigmapsigmam(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.
CollectiveSpins.reducedspin.reducedspinstate
— Functionreducedspinstate(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
Collective Modes
CollectiveSpins.collective_modes.Omega_k_chain
— FunctionOmega_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.
CollectiveSpins.collective_modes.Gamma_k_chain
— FunctionGamma_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.
CollectiveSpins.collective_modes.Omega_k_2D
— FunctionOmega_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.
CollectiveSpins.collective_modes.Gamma_k_2D
— FunctionGamma_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.