In [1]:
from qutip import *
import time
import numpy as np
In [2]:
# Definition of base Qobj and coeff
N = 4
t = 1.0
a = destroy(N)
ad = create(N)
n = create(N)*destroy(N)
I = qeye(N)
In [3]:
cte_QobjEvo = QobjEvo(a)
#The Qobj at t is obtain by obj(t)
cte_QobjEvo(0.)
Out[3]:
In [4]:
cte_QobjEvo(1.)
Out[4]:
In [5]:
def sin_t(t, args):
return np.sin(t)
def cos_t(t, args):
return np.cos(t)
In [6]:
# QobjEvo with function based coeff
func_QobjEvo = QobjEvo([n,[a+ad,cos_t]])
func_QobjEvo(0.)
Out[6]:
In [7]:
func_QobjEvo(3.1416)
Out[7]:
In [8]:
# QobjEvo with function based coeff
str_QobjEvo = QobjEvo([n,[a+ad,"cos(t)"]])
str_QobjEvo(0.)
Out[8]:
In [9]:
str_QobjEvo(3.1416)
Out[9]:
In [10]:
tlist = np.linspace(0,10,101)
array_QobjEvo = QobjEvo([n, [a+ad,np.cos(tlist)]],tlist=tlist)
array_QobjEvo(0.)
Out[10]:
In [11]:
array_QobjEvo(3.1416)
Out[11]:
In [12]:
tlistlog = np.logspace(-3,1,1001)
Log_array_QobjEvo = QobjEvo([n, [a+ad,np.cos(tlistlog)]],tlist=tlistlog)
Log_array_QobjEvo(0.)
Out[12]:
In [13]:
Log_array_QobjEvo(3.1416)
Out[13]:
In [14]:
def coeff_with_args(t, args):
return t + args['w']
td_args = QobjEvo([I, coeff_with_args], args={'w':1.})
td_args(0)
Out[14]:
In [15]:
td_args(1)
Out[15]:
In [16]:
td_args(0, args={"w":10})
Out[16]:
In [17]:
td_args_str = QobjEvo([I, "t+w"], args={'w':1.})
td_args_str(0)
Out[17]:
In [18]:
td_args_str(1)
Out[18]:
In [19]:
td_args_str(0, args={"w":10})
Out[19]:
In [20]:
# Example of object as value
td_args_str = QobjEvo([I, "w(t)"], args={'w':np.cos})
td_args_str.compile()
In [21]:
td_args_str(0.)
Out[21]:
In [22]:
td_args_str(3.1416)
Out[22]:
The state of the solver can be accessed in arguments.
The initial value is taken from Qobj0 or 0 for expect.
Later call will use the last available value.
Main solvers ([se/me/mc]solve) update at each call.
In [23]:
args={"state_as_vec" + "=vec":basis(4,3),
"state_as_mat" + "=mat":basis(4,3),
"state_as_Qobj" + "=Qobj":basis(4,3),
"e1" + "=expect":n}
def print_args(t, args):
for key in args:
print(args[key])
return t
td_args = QobjEvo([I, print_args], args=args)
td_args(0)
Out[23]:
In [24]:
td_args(0, state=basis(4,2))
Out[24]:
In [25]:
class coeff:
def __init__(self):
self.ts = []
def call(self, t, args):
self.ts.append((t,args["e1"]))
return np.sin(t)
my_coeff = coeff()
H = QobjEvo([I+(a+ad), my_coeff.call], args={"e1=expect":n})
sesolve(H, basis(4,2), [0, 0.01])
my_coeff.ts
Out[25]:
In [26]:
td_args(1, state=basis(4,2))
Out[26]:
Some solver may call the system at previous time step.
t=1. then t=0.5 then t=1.5 etc.
In [27]:
(array_QobjEvo * 2)(0)
Out[27]:
In [28]:
(array_QobjEvo + 1 + a)(0)
Out[28]:
In [29]:
liouv = liouvillian(array_QobjEvo, c_ops=[cte_QobjEvo])
liouv(0)
Out[29]: