[Python] Is there a smarter way to implement time-dependence than as tlist-length operator...

In my system, the Hamiltonian and Lindblad operators are time-dependent in the following way.

The Hamiltonian is a coupled two-level system that depends on a detuning-parameter. That is, as a function of the detuning parameter, the splitting between the two energy levels changes.

The Lindblad operators act on the dressed states, i.e. the eigenstates of the Hamiltonian. For example, I would obtain a relaxation operator by rotating an operator L1 = np.array([[0,0],[np.sqrt(γ),0]]) into the eigenbasis, with L1 = evecs @ L1 @ evecs.transpose().conjugate(), where evecs are a list of eigenvectors.

I'm trying to implement a simulation where the detuning changes with time.

Since the time dependence changes the operator form, instead of being a multiplying factor that depends on time, I'm implementing the Hamiltonian and Lindbladian both as lists of length tlist (the time window). In other words, like this

H = [*[[qutip.Qobj(H_list[i_t]), partial(list_time_dependence, i_t)] for i_t in range(len(tlist))]]

L1_eigenbasis_list = [eigenbasis_rotated_operator(L1, H_list[i_t]) for i_t in range(len(tlist))]
L = [*[[qutip.Qobj(L1_eigenbasis_list[i_t]), partial(list_time_dependence, i_t)] for i_t in range(len(tlist))]]


where list_time_dependence is a function that picks 1 for the correct time index, and 0 otherwise.

This works but is very slow. In particular, the speed depends on the timescale (compared to Lindblad timescales) at which detuning changes. Are there any other, faster, ways in qutip or another package to implement what I want?

Continue reading...