def enr_identity(dims, excitations):
"""
Generate the identity operator for the excitation-number restricted
state space defined by the `dims` and `exciations` arguments. See the
docstring for enr_fock for a more detailed description of these arguments.
Parameters
----------
dims : list
A list of the dimensions of each subsystem of a composite quantum
system.
excitations : integer
The maximum number of excitations that are to be included in the
state space.
state : list of integers
The state in the number basis representation.
Returns
-------
op : Qobj
A Qobj instance that represent the identity operator in the
exication-number-restricted state space defined by `dims` and
`exciations`.
"""
from qutip.states import enr_state_dictionaries
nstates, _, _ = enr_state_dictionaries(dims, excitations)
data = sp.eye(nstates, nstates, dtype=np.complex)
return Qobj(data, dims=[dims, dims])
def enr_identity(dims, excitations):
"""
Generate the identity operator for the excitation-number restricted
state space defined by the `dims` and `exciations` arguments. See the
docstring for enr_fock for a more detailed description of these arguments.
Parameters
----------
dims : list
A list of the dimensions of each subsystem of a composite quantum
system.
excitations : integer
The maximum number of excitations that are to be included in the
state space.
state : list of integers
The state in the number basis representation.
Returns
-------
op : Qobj
A Qobj instance that represent the identity operator in the
exication-number-restricted state space defined by `dims` and
`exciations`.
"""
from qutip.states import enr_state_dictionaries
nstates, _, _ = enr_state_dictionaries(dims, excitations)
data = sp.eye(nstates, nstates, dtype=np.complex)
return Qobj(data, dims=[dims, dims])
def enr_destroy(dims, excitations):
"""
Generate annilation operators for modes in a excitation-number-restricted
state space. For example, consider a system consisting of 4 modes, each
with 5 states. The total hilbert space size is 5**4 = 625. If we are
only interested in states that contain up to 2 excitations, we only need
to include states such as
(0, 0, 0, 0)
(0, 0, 0, 1)
(0, 0, 0, 2)
(0, 0, 1, 0)
(0, 0, 1, 1)
(0, 0, 2, 0)
...
This function creates annihilation operators for the 4 modes that act
within this state space:
a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
From this point onwards, the annihiltion operators a1, ..., a4 can be
used to setup a Hamiltonian, collapse operators and expectation-value
operators, etc., following the usual pattern.
Parameters
----------
dims : list
A list of the dimensions of each subsystem of a composite quantum
system.
excitations : integer
The maximum number of excitations that are to be included in the
state space.
Returns
-------
a_ops : list of qobj
A list of annihilation operators for each mode in the composite
quantum system described by dims.
"""
from qutip.states import enr_state_dictionaries
nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
a_ops = [
sp.lil_matrix((nstates, nstates), dtype=np.complex128)
for _ in range(len(dims))
]
for n1, state1 in enumerate(idx2state):
for idx, s in enumerate(state1):
# if s > 0, the annihilation operator of mode idx has a non-zero
# entry with one less excitation in mode idx in the final state
if s > 0:
state2 = state1[:idx] + (s - 1, ) + state1[idx + 1:]
n2 = state2idx[state2]
a_ops[idx][n2, n1] = np.sqrt(s)
return [Qobj(a, dims=[dims, dims]) for a in a_ops]
def enr_destroy(dims, excitations):
"""
Generate annilation operators for modes in a excitation-number-restricted
state space. For example, consider a system consisting of 4 modes, each
with 5 states. The total hilbert space size is 5**4 = 625. If we are
only interested in states that contain up to 2 excitations, we only need
to include states such as
(0, 0, 0, 0)
(0, 0, 0, 1)
(0, 0, 0, 2)
(0, 0, 1, 0)
(0, 0, 1, 1)
(0, 0, 2, 0)
...
This function creates annihilation operators for the 4 modes that act
within this state space:
a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)
From this point onwards, the annihiltion operators a1, ..., a4 can be
used to setup a Hamiltonian, collapse operators and expectation-value
operators, etc., following the usual pattern.
Parameters
----------
dims : list
A list of the dimensions of each subsystem of a composite quantum
system.
excitations : integer
The maximum number of excitations that are to be included in the
state space.
Returns
-------
a_ops : list of qobj
A list of annihilation operators for each mode in the composite
quantum system described by dims.
"""
from qutip.states import enr_state_dictionaries
nstates, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
a_ops = [sp.lil_matrix((nstates, nstates), dtype=np.complex)
for _ in range(len(dims))]
for n1, state1 in idx2state.items():
for n2, state2 in idx2state.items():
for idx, a in enumerate(a_ops):
s1 = [s for idx2, s in enumerate(state1) if idx != idx2]
s2 = [s for idx2, s in enumerate(state2) if idx != idx2]
if (state1[idx] == state2[idx] - 1) and (s1 == s2):
a_ops[idx][n1, n2] = np.sqrt(state2[idx])
return [Qobj(a, dims=[dims, dims]) for a in a_ops]
def configure(self,
H_sys,
coup_op,
coup_strength,
temperature,
N_cut,
N_exp,
cut_freq,
planck=None,
boltzmann=None,
renorm=None,
bnd_cut_approx=None,
options=None,
progress_bar=None,
stats=None):
"""
Calls configure from :class:`HEOMSolver` and sets any attributes
that are specific to this subclass
"""
start_config = timeit.default_timer()
HEOMSolver.configure(self,
H_sys,
coup_op,
coup_strength,
temperature,
N_cut,
N_exp,
planck=planck,
boltzmann=boltzmann,
options=options,
progress_bar=progress_bar,
stats=stats)
self.cut_freq = cut_freq
if renorm is not None: self.renorm = renorm
if bnd_cut_approx is not None: self.bnd_cut_approx = bnd_cut_approx
# Load local values for optional parameters
# Constants and Hamiltonian.
hbar = self.planck
options = self.options
progress_bar = self.progress_bar
stats = self.stats
if stats:
ss_conf = stats.sections.get('config')
if ss_conf is None:
ss_conf = stats.add_section('config')
c, nu = self._calc_matsubara_params()
if renorm:
norm_plus, norm_minus = self._calc_renorm_factors()
if stats:
stats.add_message('options', 'renormalisation', ss_conf)
# Dimensions et by system
sup_dim = H_sys.dims[0][0]**2
unit_sys = qeye(H_sys.dims[0])
# Use shorthands (mainly as in referenced PRL)
lam0 = self.coup_strength
gam = self.cut_freq
N_c = self.N_cut
N_m = self.N_exp
Q = coup_op # Q as shorthand for coupling operator
beta = 1.0 / (self.boltzmann * self.temperature)
# Ntot is the total number of ancillary elements in the hierarchy
# Ntot = factorial(N_c + N_m) / (factorial(N_c)*factorial(N_m))
# Turns out to be the same as nstates from state_number_enumerate
N_he, he2idx, idx2he = enr_state_dictionaries([N_c + 1] * N_m, N_c)
unit_helems = fast_identity(N_he)
if self.bnd_cut_approx:
# the Tanimura boundary cut off operator
if stats:
stats.add_message('options', 'boundary cutoff approx', ss_conf)
op = -2 * spre(Q) * spost(Q.dag()) + spre(Q.dag() * Q) + spost(
Q.dag() * Q)
approx_factr = ((2 * lam0 /
(beta * gam * hbar)) - 1j * lam0) / hbar
for k in range(N_m):
approx_factr -= (c[k] / nu[k])
L_bnd = -approx_factr * op.data
L_helems = zcsr_kron(unit_helems, L_bnd)
else:
L_helems = fast_csr_matrix(shape=(N_he * sup_dim, N_he * sup_dim))
# Build the hierarchy element interaction matrix
if stats: start_helem_constr = timeit.default_timer()
unit_sup = spre(unit_sys).data
spreQ = spre(Q).data
spostQ = spost(Q).data
commQ = (spre(Q) - spost(Q)).data
N_he_interact = 0
for he_idx in range(N_he):
he_state = list(idx2he[he_idx])
n_excite = sum(he_state)
# The diagonal elements for the hierarchy operator
# coeff for diagonal elements
sum_n_m_freq = 0.0
for k in range(N_m):
sum_n_m_freq += he_state[k] * nu[k]
op = -sum_n_m_freq * unit_sup
L_he = cy_pad_csr(op, N_he, N_he, he_idx, he_idx)
L_helems += L_he
# Add the neighour interations
he_state_neigh = copy(he_state)
for k in range(N_m):
n_k = he_state[k]
if n_k >= 1:
# find the hierarchy element index of the neighbour before
# this element, for this Matsubara term
he_state_neigh[k] = n_k - 1
he_idx_neigh = he2idx[tuple(he_state_neigh)]
op = c[k] * spreQ - np.conj(c[k]) * spostQ
if renorm:
op = -1j * norm_minus[n_k, k] * op
else:
op = -1j * n_k * op
L_he = cy_pad_csr(op, N_he, N_he, he_idx, he_idx_neigh)
L_helems += L_he
N_he_interact += 1
he_state_neigh[k] = n_k
if n_excite <= N_c - 1:
# find the hierarchy element index of the neighbour after
# this element, for this Matsubara term
he_state_neigh[k] = n_k + 1
he_idx_neigh = he2idx[tuple(he_state_neigh)]
op = commQ
if renorm:
op = -1j * norm_plus[n_k, k] * op
else:
op = -1j * op
L_he = cy_pad_csr(op, N_he, N_he, he_idx, he_idx_neigh)
L_helems += L_he
N_he_interact += 1
he_state_neigh[k] = n_k
if stats:
stats.add_timing('hierarchy contruct',
timeit.default_timer() - start_helem_constr,
ss_conf)
stats.add_count('Num hierarchy elements', N_he, ss_conf)
stats.add_count('Num he interactions', N_he_interact, ss_conf)
# Setup Liouvillian
if stats:
start_louvillian = timeit.default_timer()
H_he = zcsr_kron(unit_helems, liouvillian(H_sys).data)
L_helems += H_he
if stats:
stats.add_timing('Liouvillian contruct',
timeit.default_timer() - start_louvillian,
ss_conf)
if stats: start_integ_conf = timeit.default_timer()
r = scipy.integrate.ode(cy_ode_rhs)
r.set_f_params(L_helems.data, L_helems.indices, L_helems.indptr)
r.set_integrator('zvode',
method=options.method,
order=options.order,
atol=options.atol,
rtol=options.rtol,
nsteps=options.nsteps,
first_step=options.first_step,
min_step=options.min_step,
max_step=options.max_step)
if stats:
time_now = timeit.default_timer()
stats.add_timing('Liouvillian contruct',
time_now - start_integ_conf, ss_conf)
if ss_conf.total_time is None:
ss_conf.total_time = time_now - start_config
else:
ss_conf.total_time += time_now - start_config
self._ode = r
self._N_he = N_he
self._sup_dim = sup_dim
self._configured = True
def configure(self, H_sys, coup_op, coup_strength, temperature,
N_cut, N_exp, cut_freq, planck=None, boltzmann=None,
renorm=None, bnd_cut_approx=None,
options=None, progress_bar=None, stats=None):
"""
Calls configure from :class:`HEOMSolver` and sets any attributes
that are specific to this subclass
"""
start_config = timeit.default_timer()
HEOMSolver.configure(self, H_sys, coup_op, coup_strength,
temperature, N_cut, N_exp,
planck=planck, boltzmann=boltzmann,
options=options, progress_bar=progress_bar, stats=stats)
self.cut_freq = cut_freq
if renorm is not None: self.renorm = renorm
if bnd_cut_approx is not None: self.bnd_cut_approx = bnd_cut_approx
# Load local values for optional parameters
# Constants and Hamiltonian.
hbar = self.planck
options = self.options
progress_bar = self.progress_bar
stats = self.stats
if stats:
ss_conf = stats.sections.get('config')
if ss_conf is None:
ss_conf = stats.add_section('config')
c, nu = self._calc_matsubara_params()
if renorm:
norm_plus, norm_minus = self._calc_renorm_factors()
if stats:
stats.add_message('options', 'renormalisation', ss_conf)
# Dimensions et by system
sup_dim = H_sys.dims[0][0]**2
unit_sys = qeye(H_sys.dims[0])
# Use shorthands (mainly as in referenced PRL)
lam0 = self.coup_strength
gam = self.cut_freq
N_c = self.N_cut
N_m = self.N_exp
Q = coup_op # Q as shorthand for coupling operator
beta = 1.0/(self.boltzmann*self.temperature)
# Ntot is the total number of ancillary elements in the hierarchy
# Ntot = factorial(N_c + N_m) / (factorial(N_c)*factorial(N_m))
# Turns out to be the same as nstates from state_number_enumerate
N_he, he2idx, idx2he = enr_state_dictionaries([N_c + 1]*N_m , N_c)
unit_helems = sp.identity(N_he, format='csr')
if self.bnd_cut_approx:
# the Tanimura boundary cut off operator
if stats:
stats.add_message('options', 'boundary cutoff approx', ss_conf)
op = -2*spre(Q)*spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)
approx_factr = ((2*lam0 / (beta*gam*hbar)) - 1j*lam0) / hbar
for k in range(N_m):
approx_factr -= (c[k] / nu[k])
L_bnd = -approx_factr*op.data
L_helems = sp.kron(unit_helems, L_bnd)
else:
L_helems = sp.csr_matrix((N_he*sup_dim, N_he*sup_dim),
dtype=complex)
# Build the hierarchy element interaction matrix
if stats: start_helem_constr = timeit.default_timer()
unit_sup = spre(unit_sys).data
spreQ = spre(Q).data
spostQ = spost(Q).data
commQ = (spre(Q) - spost(Q)).data
N_he_interact = 0
for he_idx in range(N_he):
he_state = list(idx2he[he_idx])
n_excite = sum(he_state)
# The diagonal elements for the hierarchy operator
# coeff for diagonal elements
sum_n_m_freq = 0.0
for k in range(N_m):
sum_n_m_freq += he_state[k]*nu[k]
op = -sum_n_m_freq*unit_sup
L_he = _pad_csr(op, N_he, N_he, he_idx, he_idx)
L_helems += L_he
# Add the neighour interations
he_state_neigh = copy(he_state)
for k in range(N_m):
n_k = he_state[k]
if n_k >= 1:
# find the hierarchy element index of the neighbour before
# this element, for this Matsubara term
he_state_neigh[k] = n_k - 1
he_idx_neigh = he2idx[tuple(he_state_neigh)]
op = c[k]*spreQ - np.conj(c[k])*spostQ
if renorm:
op = -1j*norm_minus[n_k, k]*op
else:
op = -1j*n_k*op
L_he = _pad_csr(op, N_he, N_he, he_idx, he_idx_neigh)
L_helems += L_he
N_he_interact += 1
he_state_neigh[k] = n_k
if n_excite <= N_c - 1:
# find the hierarchy element index of the neighbour after
# this element, for this Matsubara term
he_state_neigh[k] = n_k + 1
he_idx_neigh = he2idx[tuple(he_state_neigh)]
op = commQ
if renorm:
op = -1j*norm_plus[n_k, k]*op
else:
op = -1j*op
L_he = _pad_csr(op, N_he, N_he, he_idx, he_idx_neigh)
L_helems += L_he
N_he_interact += 1
he_state_neigh[k] = n_k
if stats:
stats.add_timing('hierarchy contruct',
timeit.default_timer() - start_helem_constr,
ss_conf)
stats.add_count('Num hierarchy elements', N_he, ss_conf)
stats.add_count('Num he interactions', N_he_interact, ss_conf)
# Setup Liouvillian
if stats: start_louvillian = timeit.default_timer()
H_he = sp.kron(unit_helems, liouvillian(H_sys).data)
L_helems += H_he
if stats:
stats.add_timing('Liouvillian contruct',
timeit.default_timer() - start_louvillian,
ss_conf)
if stats: start_integ_conf = timeit.default_timer()
r = scipy.integrate.ode(cy_ode_rhs)
r.set_f_params(L_helems.data, L_helems.indices, L_helems.indptr)
r.set_integrator('zvode', method=options.method, order=options.order,
atol=options.atol, rtol=options.rtol,
nsteps=options.nsteps, first_step=options.first_step,
min_step=options.min_step, max_step=options.max_step)
if stats:
time_now = timeit.default_timer()
stats.add_timing('Liouvillian contruct',
time_now - start_integ_conf,
ss_conf)
if ss_conf.total_time is None:
ss_conf.total_time = time_now - start_config
else:
ss_conf.total_time += time_now - start_config
self._ode = r
self._N_he = N_he
self._sup_dim = sup_dim
self._configured = True