def run(neq=10, ntraj=100, solver='both', ncpus=1): # sparse initial state # psi0 = basis(neq,neq-1) # dense initial state psi0 = qt.Qobj(np.ones((neq, 1))).unit() a = qt.destroy(neq) ad = a.dag() H = ad * a # c_ops = [gamma*a] c_ops = [qt.qeye(neq)] e_ops = [ad * a] # Times T = 10.0 dt = 0.1 nstep = int(T / dt) tlist = np.linspace(0, T, nstep) # set options opts = qt.Options() opts.num_cpus = ncpus opts.gui = False mcf90_time = 0. mc_time = 0. if (solver == 'mcf90' or solver == 'both'): start_time = time.time() mcf90.mcsolve_f90(H, psi0, tlist, c_ops, e_ops, ntraj=ntraj, options=opts) mcf90_time = time.time() - start_time print("mcsolve_f90 solutiton took", mcf90_time, "s") if (solver == 'mc' or solver == 'both'): start_time = time.time() qt.mcsolve(H, psi0, tlist, c_ops, e_ops, ntraj=ntraj, options=opts, progress_bar=False) mc_time = time.time() - start_time print("mcsolve solutiton took", mc_time, "s") return mcf90_time, mc_time
def run(): wa = 1.0 * 2 * pi # frequency of system a wb = 1.0 * 2 * pi # frequency of system a wab = 0.2 * 2 * pi # coupling frequency ga = 0.2 * 2 * pi # dissipation rate of system a gb = 0.1 * 2 * pi # dissipation rate of system b Na = 10 # number of states in system a Nb = 10 # number of states in system b E = 1.0 * 2 * pi # Oscillator A driving strength a = tensor(destroy(Na), qeye(Nb)) b = tensor(qeye(Na), destroy(Nb)) na = a.dag() * a nb = b.dag() * b H = wa*na + wb*nb + wab*(a.dag()*b+a*b.dag()) + E*(a.dag()+a) # start with both oscillators in ground state psi0 = tensor(basis(Na), basis(Nb)) c_op_list = [] c_op_list.append(sqrt(ga) * a) c_op_list.append(sqrt(gb) * b) tlist = linspace(0, 5, 101) #run simulation data = mcf90.mcsolve_f90(H,psi0,tlist,c_op_list,[na,nb]) #data = mcsolve(H,psi0,tlist,c_op_list,[na,nb]) #plot results plot(tlist,data.expect[0],'b',tlist,data.expect[1],'r',lw=2) xlabel('Time',fontsize=14) ylabel('Excitations',fontsize=14) legend(('Oscillator A', 'Oscillator B')) show()
def integrate(N, h, Jx, Jy, Jz, psi0, tlist, gamma, solver): # # Hamiltonian # # H = - 0.5 sum_n^N h_n sigma_z(n) # - 0.5 sum_n^(N-1) [ Jx_n sigma_x(n) sigma_x(n+1) + # Jy_n sigma_y(n) sigma_y(n+1) + # Jz_n sigma_z(n) sigma_z(n+1)] # si = qeye(2) sx = sigmax() sy = sigmay() sz = sigmaz() sx_list = [] sy_list = [] sz_list = [] for n in range(N): op_list = [] for m in range(N): op_list.append(si) op_list[n] = sx sx_list.append(tensor(op_list)) op_list[n] = sy sy_list.append(tensor(op_list)) op_list[n] = sz sz_list.append(tensor(op_list)) # construct the hamiltonian H = 0 # energy splitting terms for n in range(N): H += - 0.5 * h[n] * sz_list[n] # interaction terms for n in range(N-1): H += - 0.5 * Jx[n] * sx_list[n] * sx_list[n+1] H += - 0.5 * Jy[n] * sy_list[n] * sy_list[n+1] H += - 0.5 * Jz[n] * sz_list[n] * sz_list[n+1] # collapse operators c_op_list = [] # spin dephasing for n in range(N): if gamma[n] > 0.0: c_op_list.append(sqrt(gamma[n]) * sz_list[n]) # evolve and calculate expectation values if solver == "me": output = mesolve(H, psi0, tlist, c_op_list, sz_list) elif solver == "mc": output = mcsolve(H, psi0, tlist, c_op_list, sz_list) elif solver == "mcf90": output = mcf90.mcsolve_f90(H, psi0, tlist, c_op_list, sz_list) return output.expect
def run(): #number of states for each mode N0=15 N1=15 N2=15 #define operators a0=tensor(destroy(N0),qeye(N1),qeye(N2)) a1=tensor(qeye(N0),destroy(N1),qeye(N2)) a2=tensor(qeye(N0),qeye(N1),destroy(N2)) #number operators for each mode num0=a0.dag()*a0 num1=a1.dag()*a1 num2=a2.dag()*a2 #initial state: coherent mode 0 & vacuum for modes #1 & #2 alpha=sqrt(7)#initial coherent state param for mode 0 psi0=tensor(coherent(N0,alpha),basis(N1,0),basis(N2,0)) #trilinear Hamiltonian H=1.0j*(a0*a1.dag()*a2.dag()-a0.dag()*a1*a2) #run Monte-Carlo tlist=linspace(0,2.5,50) output=mcf90.mcsolve_f90(H,psi0,tlist,[],[],ntraj=1) #output=mcsolve(H,psi0,tlist,[],[],ntraj=1) #extrace mode 1 using ptrace mode1=[psi.ptrace(1) for psi in output.states] #get diagonal elements diags1=[k.diag() for k in mode1] #calculate num of particles in mode 1 num1=[expect(num1,k) for k in output.states] #generate thermal state with same # of particles thermal=[thermal_dm(N1,k).diag() for k in num1] #plot results from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm colors=['m', 'g','orange','b', 'y','pink'] x=arange(N1) params = {'axes.labelsize': 14,'text.fontsize': 14,'legend.fontsize': 12,'xtick.labelsize': 14,'ytick.labelsize': 14} rcParams.update(params) fig = plt.figure() ax = Axes3D(fig) for j in range(5): ax.bar(x, diags1[10*j], zs=tlist[10*j], zdir='y',color=colors[j],linewidth=1.0,alpha=0.6,align='center') ax.plot(x,thermal[10*j],zs=tlist[10*j],zdir='y',color='r',linewidth=3,alpha=1) ax.set_zlabel(r'Probability') ax.set_xlabel(r'Number State') ax.set_ylabel(r'Time') ax.set_zlim3d(0,1) show()
def run(neq=10, ntraj=100, solver='both', ncpus=1): # sparse initial state # psi0 = basis(neq,neq-1) # dense initial state psi0 = qt.Qobj(np.ones((neq, 1))).unit() a = qt.destroy(neq) ad = a.dag() H = ad*a # c_ops = [gamma*a] c_ops = [qt.qeye(neq)] e_ops = [ad*a] # Times T = 10.0 dt = 0.1 nstep = int(T/dt) tlist = np.linspace(0, T, nstep) # set options opts = qt.Options() opts.num_cpus = ncpus opts.gui = False mcf90_time = 0. mc_time = 0. if (solver == 'mcf90' or solver == 'both'): start_time = time.time() mcf90.mcsolve_f90(H, psi0, tlist, c_ops, e_ops, ntraj=ntraj, options=opts) mcf90_time = time.time()-start_time print("mcsolve_f90 solutiton took", mcf90_time, "s") if (solver == 'mc' or solver == 'both'): start_time = time.time() qt.mcsolve(H, psi0, tlist, c_ops, e_ops, ntraj=ntraj, options=opts, progress_bar=False) mc_time = time.time()-start_time print("mcsolve solutiton took", mc_time, "s") return mcf90_time, mc_time
def run(): #number of states for each mode N0=6 N1=6 N2=6 #damping rates gamma0=0.1 gamma1=0.4 gamma2=0.1 alpha=sqrt(2)#initial coherent state param for mode 0 tlist=linspace(0,4,200) ntraj=500#number of trajectories #define operators a0=tensor(destroy(N0),qeye(N1),qeye(N2)) a1=tensor(qeye(N0),destroy(N1),qeye(N2)) a2=tensor(qeye(N0),qeye(N1),destroy(N2)) #number operators for each mode num0=a0.dag()*a0 num1=a1.dag()*a1 num2=a2.dag()*a2 #dissipative operators for zero-temp. baths C0=sqrt(2.0*gamma0)*a0 C1=sqrt(2.0*gamma1)*a1 C2=sqrt(2.0*gamma2)*a2 #initial state: coherent mode 0 & vacuum for modes #1 & #2 psi0=tensor(coherent(N0,alpha),basis(N1,0),basis(N2,0)) #trilinear Hamiltonian H=1j*(a0*a1.dag()*a2.dag()-a0.dag()*a1*a2) #run Monte-Carlo data=mcf90.mcsolve_f90(H,psi0,tlist,[C0,C1,C2],[num0,num1,num2]) #data=mcsolve(H,psi0,tlist,[C0,C1,C2],[num0,num1,num2]) #plot results fig = figure() ax = fig.add_subplot(111) cs=['b','r','g'] #set three colors, one for each operator for k in range(ntraj): if len(data.col_times[k])>0:#just in case no collapse colors=[cs[j] for j in data.col_which[k]]#set color xdat=[k for x in range(len(data.col_times[k]))] ax.scatter(xdat,data.col_times[k],marker='o',c=colors) ax.set_xlim([-1,ntraj+1]) ax.set_ylim([0,tlist[-1]]) ax.set_xlabel('Trajectory',fontsize=14) ax.set_ylabel('Collpase Time',fontsize=14) ax.set_title('Blue = C0, Red = C1, Green= C2') show()
def test_MCSimpleConst(): "Monte-carlo: Constant H with constant collapse" N=10 #number of basis states to consider a=destroy(N) H=a.dag()*a psi0=basis(N,9) #initial state kappa=0.2 #coupling to oscillator c_op_list=[sqrt(kappa)*a] tlist=linspace(0,10,100) mcdata=mcsolve_f90(H,psi0,tlist,c_op_list,[a.dag()*a],options=Odeoptions(gui=False)) expt=mcdata.expect[0] actual_answer=9.0*exp(-kappa*tlist) avg_diff=mean(abs(actual_answer-expt)/actual_answer) assert_equal(avg_diff<mc_error,True)
def test_MCNoCollExpt(): "Monte-carlo: Constant H with no collapse ops (expect)" error=1e-8 N=10 #number of basis states to consider a=destroy(N) H=a.dag()*a psi0=basis(N,9) #initial state kappa=0.2 #coupling to oscillator c_op_list=[] tlist=linspace(0,10,100) mcdata=mcsolve_f90(H,psi0,tlist,c_op_list,[a.dag()*a],options=Odeoptions(gui=False)) expt=mcdata.expect[0] actual_answer=9.0*ones(len(tlist)) diff=mean(abs(actual_answer-expt)/actual_answer) assert_equal(diff<error,True)
def ptracetest(): gamma = 1. neq = 2 psi0 = qt.basis(neq,neq-1) psi0 = qt.tensor(psi0,psi0) H = qt.tensor(qt.sigmax(),qt.sigmay()) c1 = np.sqrt(gamma)*qt.sigmax() e1 = np.sqrt(gamma)*qt.sigmaz() c_ops = [qt.tensor(c1,c1)] e_ops = [qt.tensor(e1,e1),qt.tensor(c1,c1)] #e_ops = [] tlist = np.linspace(0,10,100) ntraj = 2000 ptrace_sel = [0] sol_f90 = mcf90.mcsolve_f90(H,psi0,tlist,c_ops,e_ops,ntraj=ntraj, ptrace_sel=ptrace_sel,calc_entropy=True)
def run(): from mpi4py import MPI comm = MPI.COMM_WORLD size = comm.Get_size() rank = comm.Get_rank() print "Process number", rank, "of", size, "total." neq = 2 gamma = 1.0 psi0 = qt.basis(neq,neq-1) H = qt.sigmax() c_ops = [np.sqrt(gamma)*qt.sigmax()] e_ops = [qt.sigmam()*qt.sigmap()] tlist = np.linspace(0,10,100) ntraj=100 # One CPU per MPI process opts = qt.Odeoptions() opts.num_cpus = 1 # Solve sols = mcf90.mcsolve_f90(H,psi0,tlist,c_ops,e_ops,ntraj=ntraj,options=opts) #sols = qt.mcsolve(H,psi0,tlist,c_ops,e_ops,ntraj=ntraj,options=opts) # Gather data sols = comm.gather(sols,root=0) if (rank==0): sol = sols[0] sol.expect = np.array(sols[0].expect) plt.figure() plt.plot(tlist,sols[0].expect[0],'r',label='proc '+str(0)) for i in range(1,size): plt.plot(tlist,sols[i].expect[0],'r',label='proc '+str(i)) sol.expect += np.array(sols[i].expect) sol.expect = sol.expect/size plt.plot(tlist,sol.expect[0],'b',label='average') plt.legend() plt.show()
def run(): # set system parameters kappa = 2.0 # mirror coupling gamma = 0.2 # spontaneous emission rate g = 1 # atom/cavity coupling strength wc = 0 # cavity frequency w0 = 0 # atom frequency wl = 0 # driving frequency E = 0.5 # driving amplitude N = 4 # number of cavity energy levels (0->3 Fock states) tlist = linspace(0, 10, 101) # times for expectation values # construct Hamiltonian ida = qeye(N) idatom = qeye(2) a = tensor(destroy(N), idatom) sm = tensor(ida, sigmam()) H = (w0 - wl) * sm.dag() * sm + (wc - wl) * a.dag() * a + 1j * g * (a.dag() * sm - sm.dag() * a) + E * (a.dag() + a) # collapse operators C1 = sqrt(2 * kappa) * a C2 = sqrt(gamma) * sm C1dC1 = C1.dag() * C1 C2dC2 = C2.dag() * C2 # intial state psi0 = tensor(basis(N, 0), basis(2, 1)) # run monte-carlo solver with default 500 trajectories data = mcf90.mcsolve_f90(H, psi0, tlist, [C1, C2], [C1dC1, C2dC2]) # data=mcsolve(H,psi0,tlist,[C1,C2],[C1dC1,C2dC2]) # plot expectation values plot(tlist, data.expect[0], tlist, data.expect[1], lw=2) legend(("Transmitted Cavity Intensity", "Spontaneous Emission")) ylabel("Counts") xlabel("Time") show()
def test(): gamma = 1. neq = 2 psi0 = qt.basis(neq,neq-1) #a = qt.destroy(neq) #ad = a.dag() #H = ad*a #c_ops = [gamma*a] #e_ops = [ad*a] H = qt.sigmax() c_ops = [np.sqrt(gamma)*qt.sigmax()] #c_ops = [] e_ops = [qt.sigmam()*qt.sigmap(),qt.sigmap()*qt.sigmam()] #e_ops = [] # Times T = 2.0 dt = 0.1 nstep = int(T/dt) tlist = np.linspace(0,T,nstep) ntraj=100 # set options opts = qt.Odeoptions() opts.num_cpus=2 #opts.mc_avg = True #opts.gui=False #opts.max_step=1000 #opts.atol = #opts.rtol = sol_f90 = qt.Odedata() start_time = time.time() sol_f90 = mcf90.mcsolve_f90(H,psi0,tlist,c_ops,e_ops,ntraj=ntraj,options=opts) print "mcsolve_f90 solutiton took", time.time()-start_time, "s" sol_me = qt.Odedata() start_time = time.time() sol_me = qt.mesolve(H,psi0,tlist,c_ops,e_ops,options=opts) print "mesolve solutiton took", time.time()-start_time, "s" sol_mc = qt.Odedata() start_time = time.time() sol_mc = qt.mcsolve(H,psi0,tlist,c_ops,e_ops,ntraj=ntraj,options=opts) print "mcsolve solutiton took", time.time()-start_time, "s" if (e_ops == []): e_ops = [qt.sigmam()*qt.sigmap(),qt.sigmap()*qt.sigmam()] sol_f90expect = [np.array([0.+0.j]*nstep)]*len(e_ops) sol_mcexpect = [np.array([0.+0.j]*nstep)]*len(e_ops) sol_meexpect = [np.array([0.+0.j]*nstep)]*len(e_ops) for i in range(len(e_ops)): if (not opts.mc_avg): sol_f90expect[i] = sum([qt.expect(e_ops[i], sol_f90.states[j]) for j in range(ntraj)])/ntraj sol_mcexpect[i] = sum([qt.expect(e_ops[i], sol_mc.states[j]) for j in range(ntraj)])/ntraj else: sol_f90expect[i] = qt.expect(e_ops[i],sol_f90.states) sol_mcexpect[i] = qt.expect(e_ops[i],sol_mc.states) sol_meexpect[i] = qt.expect(e_ops[i],sol_me.states) elif (not opts.mc_avg): sol_f90expect = sum(sol_f90.expect,0)/ntraj sol_mcexpect = sum(sol_f90.expect,0)/ntraj sol_meexpect = sol_me.expect else: sol_f90expect = sol_f90.expect sol_mcexpect = sol_mc.expect sol_meexpect = sol_me.expect plt.figure() for i in range(len(e_ops)): plt.plot(tlist,sol_f90expect[i],'b') plt.plot(tlist,sol_mcexpect[i],'g') plt.plot(tlist,sol_meexpect[i],'k') return sol_f90, sol_mc
def run(): # define parameters N=4 # number of basis states to consider kappa=1.0/0.129 # coupling to heat bath nth= 0.063 # temperature with <n>=0.063 # create operators and initial |1> state a=destroy(N) # cavity destruction operator H=a.dag()*a # harmonic oscillator Hamiltonian psi0=basis(N,1) # initial Fock state with one photon # collapse operators c_op_list = [] # decay operator c_op_list.append(sqrt(kappa * (1 + nth)) * a) # excitation operator c_op_list.append(sqrt(kappa * nth) * a.dag()) # run monte carlo simulation ntraj=[1,5,15,904] # list of number of trajectories to avg. over tlist=linspace(0,0.6,100) mc = mcf90.mcsolve_f90(H,psi0,tlist,c_op_list,[a.dag()*a],ntraj) #mc = mcsolve(H,psi0,tlist,c_op_list,[a.dag()*a],ntraj) # get expectation values from mc data (need extra index since ntraj is list) ex1=mc.expect[0][0] #for ntraj=1 ex5=mc.expect[1][0] #for ntraj=5 ex15=mc.expect[2][0] #for ntraj=15 ex904=mc.expect[3][0] #for ntraj=904 ## run master equation to get ensemble average expectation values ## me = mesolve(H,psi0,tlist,c_op_list, [a.dag()*a]) # calulate final state using steadystate solver final_state=steadystate(H,c_op_list) # find steady-state fexpt=expect(a.dag()*a,final_state) # find expectation value for particle number # # plot results using vertically stacked plots # # set legend fontsize import matplotlib.font_manager leg_prop = matplotlib.font_manager.FontProperties(size=10) f = figure(figsize=(6,9)) subplots_adjust(hspace=0.001) #no space between plots # subplot 1 (top) ax1 = subplot(411) ax1.plot(tlist,ex1,'b',lw=2) ax1.axhline(y=fexpt,color='k',lw=1.5) yticks(linspace(0,2,5)) ylim([-0.1,1.5]) ylabel('$\left< N \\right>$',fontsize=14) title("Ensemble Averaging of Monte Carlo Trajectories") legend(('Single trajectory','steady state'),prop=leg_prop) # subplot 2 ax2=subplot(412,sharex=ax1) #share x-axis of subplot 1 ax2.plot(tlist,ex5,'b',lw=2) ax2.axhline(y=fexpt,color='k',lw=1.5) yticks(linspace(0,2,5)) ylim([-0.1,1.5]) ylabel('$\left< N \\right>$',fontsize=14) legend(('5 trajectories','steadystate'),prop=leg_prop) # subplot 3 ax3=subplot(413,sharex=ax1) #share x-axis of subplot 1 ax3.plot(tlist,ex15,'b',lw=2) ax3.plot(tlist,me.expect[0],'r--',lw=1.5) ax3.axhline(y=fexpt,color='k',lw=1.5) yticks(linspace(0,2,5)) ylim([-0.1,1.5]) ylabel('$\left< N \\right>$',fontsize=14) legend(('15 trajectories','master equation','steady state'),prop=leg_prop) # subplot 4 (bottom) ax4=subplot(414,sharex=ax1) #share x-axis of subplot 1 ax4.plot(tlist,ex904,'b',lw=2) ax4.plot(tlist,me.expect[0],'r--',lw=1.5) ax4.axhline(y=fexpt,color='k',lw=1.5) yticks(linspace(0,2,5)) ylim([-0.1,1.5]) ylabel('$\left< N \\right>$',fontsize=14) legend(('904 trajectories','master equation','steady state'),prop=leg_prop) #remove x-axis tick marks from top 3 subplots xticklabels = ax1.get_xticklabels()+ax2.get_xticklabels()+ax3.get_xticklabels() setp(xticklabels, visible=False) ax1.xaxis.set_major_locator(MaxNLocator(4)) xlabel('Time (sec)',fontsize=14) show() return mc