def func(f1, b, set): """ This function Perform the gate application on the initial state of qubit and then the state tomography, at the same time compute the analytical bloch state. INCOME: f1="string", b="string" fig_data="svg",fig_data2="svg" """ #### Create the bloch-sphere on qutip b1 = Bloch() b2 = Bloch() ## create the analyical quantum state and perform tranformation ## Add states to the bloch sphere and plot it b1.add_states(analytic(f1, b)) if not set: states = qtomography(f1, b) b2.add_vectors(states) else: ### implements for states = qtomography_s(f1, b) for i in states: b2.add_points(i) b2.add_vectors(np.average(states, axis=0)) ### b2.render() fig_data = print_figure(b2.fig, 'svg') b1.render() fig_data2 = print_figure(b1.fig, 'svg') #b1.show() #b2.show() b1.clear() b2.clear() return fig_data, fig_data2
def bloch_plot(self, points=None, F=None): """ Plot the current state on the Bloch sphere using qutip. """ # create instance of 3d plot bloch = Bloch(figsize=[9, 9]) bloch.add_vectors([0, 0, 1]) bloch.xlabel = ['$<F_x>$', ''] bloch.ylabel = ['$<F_y>$', ''] bloch.zlabel = ['$<F_z>$', ''] if self.spin == 'half': if points is None: # convert current state into density operator rho = np.outer(self.state.H, self.state) # get Bloch vector representation points = self.get_bloch_vec(rho) # Can only plot systems of dimension 2 at this time assert len( points ) == 3, "System dimension must be spin 1/2 for Bloch sphere plot" # create instance of 3d plot bloch = Bloch(figsize=[9, 9]) elif self.spin == 'one': #points is list of items in format [[x1,x2],[y1,y2],[z1,z2]] if points is None: points = [getStars(self.state)] bloch.point_color = ['g', 'r', 'b'] #ensures point and line are same colour bloch.point_marker = ['o', 'd', 'o'] #bloch.point_color = ['g','r'] #ensures point and line are same colour #bloch.point_marker = ['o','d'] for p in points: bloch.add_points([p[0][0], p[1][0], p[2][0]]) bloch.add_points([p[0][1], p[1][1], p[2][1]]) bloch.add_points(p, meth='l') ''' bloch.point_color = ['b','b'] #ensures point and line are same colour bloch.point_marker = ['o','o'] for p in points: bloch.add_points(p) bloch.add_points(p, meth='l') ''' # add state #bloch.render(bloch.fig, bloch.axes) #bloch.fig.savefig("bloch.png",dpi=600, transparent=True) bloch.show()
def bloch_field(self, time): """ Plot magnetic field vector normalised to the bloch sphere """ # seperate coordinates into axis set xb = self.fields[0](time) yb = self.fields[1](time) zb = self.fields[2](time) # add to list and normalise points = [list(xb), list(yb), list(zb)] sqsum = 0.0 for i, point in enumerate(points[0]): # compute magnitude and store largest value sqsum_test = np.sqrt(points[0][i]**2 + points[1][i]**2 + points[2][i]**2) if sqsum_test > sqsum: sqsum = sqsum_test points = points / sqsum # create Bloch sphere instance bloch = Bloch() # add points and show bloch.add_points(points) bloch.show()
def draw_sphere_zenith(zenith_points, hv_points, root): b = Bloch() b.point_color = ['m', 'k', 'g', 'b', 'w', 'c', 'y', 'r'] b.zlabel = ['$z$', ''] b.point_marker = ['o'] b.point_size = [30] b.frame_width = 1.2 fig = plt.figure(figsize=(20, 20)) b.fig = fig x = (basis(2, 0) + (1 + 0j) * basis(2, 1)).unit() y = (basis(2, 0) + (0 + 1j) * basis(2, 1)).unit() z = (basis(2, 0) + (0 + 0j) * basis(2, 1)).unit() b.add_states([x, y, z]) for i in range(len(zenith_points)): # Transform xyz to zxy coordinates tmp1 = np.array( [zenith_points[i][2], zenith_points[i][0], zenith_points[i][1]]) tmp2 = np.vstack( [hv_points[i][:, 2], hv_points[i][:, 0], hv_points[i][:, 1]]).T tmp = np.vstack([tmp1, -tmp1, tmp2]).T b.add_points(tmp) # tmp1 = np.array([zenith_points[-1][2], zenith_points[-1][0], zenith_points[-1][1]]) # tmp = np.array([tmp1, -tmp1]).T # b.add_points(tmp) name = os.path.join(root, 'zenith_on_sphere.jpg') b.save(name=name)
def draw_consensus_rectified_sphere(hv_points, root): b = Bloch() b.point_color = ['m', 'k', 'g', 'b', 'w', 'c', 'y', 'r'] b.zlabel = ['$z$', ''] b.point_marker = ['o'] b.point_size = [80] b.frame_width = 1.2 fig = plt.figure(figsize=(20, 20)) b.fig = fig x = (basis(2, 0) + (1 + 0j) * basis(2, 1)).unit() y = (basis(2, 0) + (0 + 1j) * basis(2, 1)).unit() z = (basis(2, 0) + (0 + 0j) * basis(2, 1)).unit() b.add_states([x, y, z]) for i in range(len(hv_points)): # Transform xyz to zxy coordinates tmp2 = np.vstack( [hv_points[i][:, 2], hv_points[i][:, 0], hv_points[i][:, 1]]).T tmp = tmp2.T b.add_points(tmp) # b.add_points([ 0.99619469809174555, 0.087155742747658166, 0]) # b.add_points([0.99619469809174555, -0.087155742747658166, 0]) # b.add_points(tmp) name = os.path.join(root, 'consensus_zenith_on_rectified_sphere.jpg') b.save(name=name)
def bloch_plot(self, filename, points=None, save=False): """ Plot the current state on the Bloch sphere using qutip. """ if points is None: # convert current state into density operator rho = np.outer(self.state.H, self.state) # get Bloch vector representation points = self.get_bloch_vec(rho) # Can only plot systems of dimension 2 at this time assert len( points ) == 3, "System dimension must be spin 1/2 for Bloch sphere plot" # create instance of 3d plot bloch = Bloch(fig=1, figsize=[9, 9], view=[190, 10]) # add state bloch.add_points(points) bloch.render() if save is True: print('Bloch plot saved to Sim Results folder') path = 'C:/Users/Boundsy/Desktop/Uni Work/PHS2360/Sim Results/' + str( filename) + '.png' bloch.fig.savefig(path, dpi=800, transparent=True)
def PlotStateAnalyzer(InputState, hwpAngle, qwpAngle): QWPstate = QWP(qwpAngle) @ InputState OutputState = HWP(hwpAngle) @ QWP(qwpAngle) @ InputState pntsX = [ StateToBloch(QWP(th) @ InputState)[0] for th in arange(0, pi, pi / 64) ] pntsY = [ StateToBloch(QWP(th) @ InputState)[1] for th in arange(0, pi, pi / 64) ] pntsZ = [ StateToBloch(QWP(th) @ InputState)[2] for th in arange(0, pi, pi / 64) ] pnts = [pntsX, pntsY, pntsZ] pntsX2 = [ StateToBloch(HWP(th) @ QWP(qwpAngle) @ InputState)[0] for th in arange(0, pi, pi / 64) ] pntsY2 = [ StateToBloch(HWP(th) @ QWP(qwpAngle) @ InputState)[1] for th in arange(0, pi, pi / 64) ] pntsZ2 = [ StateToBloch(HWP(th) @ QWP(qwpAngle) @ InputState)[2] for th in arange(0, pi, pi / 64) ] pnts2 = [pntsX2, pntsY2, pntsZ2] bsph = Bloch() bsph.add_points(pnts) bsph.add_points(pnts2) bsph.add_vectors(StateToBloch(OutputState)) bsph.add_vectors(StateToBloch(InputState)) bsph.add_vectors(StateToBloch(QWPstate)) return bsph.show()
def bloch_animate(self, pnts, name="Bloch_animate"): """ Animates the path of a state through the set of pure states - requires ffmpeg """ from pylab import figure import matplotlib.animation as animation from mpl_toolkits.mplot3d import Axes3D # set up plot environment fig = figure() ax = Axes3D(fig, azim=-40, elev=30) sphere = Bloch(axes=ax) # define animation function (from qutip docs) def animate(i): sphere.clear() sphere.add_points( [pnts[0][:i + 1], pnts[1][:i + 1], pnts[2][:i + 1]]) sphere.make_sphere() return ax def init(): sphere.vector_color = ['r'] return ax ani = animation.FuncAnimation(fig, animate, np.arange(len(pnts[0])), init_func=init, repeat=False) ani.save(name + ".mp4", fps=20)
def create_gif(qstates, qstart, qtarget, name): ''' Inputs: # qstates: list of states as np.arrays # qstart, qtarget: respectively the target ans start state # name: name of the output gif ''' b = Bloch() duration = 5 #framerate images = [] for (qstate, i) in zip(qstates, range(0, len(qstates))): b.clear() b.point_color = "r" # options: 'r', 'g', 'b' etc. b.point_marker = ['o'] b.point_size = [40] b.add_states(qutip_qstate(qstart)) b.add_states(qutip_qstate(qtarget)) for previous in range(i): b.add_states(qutip_qstate(qstates[previous]), "point") #plots previous visited states as points b.add_states(qutip_qstate(qstate)) filename = 't.png' b.save(filename) images.append(imageio.imread(filename)) imageio.mimsave(name, images, 'GIF', fps=duration)
def __enter__(self): from qutip import Bloch3d, Bloch plt.ion() self.fig = plt.figure(figsize=self.figsize) self.ax = Axes3D(self.fig, azim=-30, elev=15) self.ball = Bloch(axes=self.ax) self.ball.zlabel = [r'$|N\rangle$', r'$|S\rangle$'] return self
def plot_quantum_state(amplitudes): """ Thin function to abstract the plotting on the Bloch sphere. """ bloch_sphere = Bloch() vec = get_vector(amplitudes[0], amplitudes[1]) bloch_sphere.add_vectors(vec) bloch_sphere.show() bloch_sphere.clear()
def PlotStateQWP(InputState, qwpAngle): OutputState = QWP(qwpAngle) @ InputState pntsX = [ StateToBloch(QWP(th) @ InputState)[0] for th in arange(0, pi, pi / 64) ] pntsY = [ StateToBloch(QWP(th) @ InputState)[1] for th in arange(0, pi, pi / 64) ] pntsZ = [ StateToBloch(QWP(th) @ InputState)[2] for th in arange(0, pi, pi / 64) ] pnts = [pntsX, pntsY, pntsZ] bsph = Bloch() bsph.add_points(pnts) bsph.add_vectors(StateToBloch(OutputState)) bsph.add_vectors(StateToBloch(InputState)) return bsph.show()
def bloch_from_dataframe(df, fig, axes): """ Plot Bloch sphere :param df: pd.DataFrame :param axes: :return: """ bloch = Bloch(fig=fig, axes=axes) bloch.vector_color = plt.get_cmap('viridis')(np.linspace(0, 1, len(df))) bloch.add_states([ Qobj([[row.Jxx, row.beta + 1j * row.gamma], [row.beta - 1j * row.gamma, row.Jyy]]) for _, row in df.iterrows() ]) bloch.make_sphere()
def animate_bloch(vectors, duration=0.1, save_all=False): numberOfLoops = 1 #Enter '1' to apply only ONE mode [Excitation or Relaxation] or '2' to to apply only BOTH modes [Excitation and Relaxation] starting with the selected mode if numberOfLoops == 1: maxAngle = 2 * np.pi elif numberOfLoops == 2: maxAngle = 4 * np.pi mode = 1 #Enter '0' to activate Excitation Mode or '1' to activate Relaxation Mode omega = np.pi / 6 #Enter the angular frequency z = 0 sqAngle = np.pi / 2 a = 5 vectorM = Bloch() # vectorM.view = [90,90] #Activate this line to view magnetization’s trajectory on x-y plane images = [] for t in np.arange(omega, maxAngle, 0.1): if mode == 0: z = np.pi / 2 * np.sin(t / (4)) if t == 2 * np.pi: mode = 1 elif mode == 1: z = np.pi / 2 * np.cos(t / (4)) if t == 2 * np.pi: mode = 0 else: pass vectorM.clear() vectorM.add_vectors([ np.sin(omega) * np.cos(t), np.sin(omega) * np.sin(t), np.cos(omega) ]) vectorM.add_vectors( [np.sin(z) * np.cos(a * t), np.sin(z) * np.sin(a * t), np.cos(z)]) vectorM.add_vectors([ np.sin(sqAngle) * np.cos(t), np.sin(sqAngle) * np.sin(t), np.cos(sqAngle) ]) filename = 'temp_file.png' vectorM.save(filename) images.append(imageio.imread(filename)) imageio.mimsave('bloch_anim.gif', images, duration=duration)
def field_plot(self, params, bloch=[False, 1]): """ Plots the signal components given simulation parameters over the specified time doman """ # get time varying fields and simulation data time, cparams, Bfields = field_get(params=params) # plot magnetic field vector on Bloch sphere if bloch[0]: Bfields = Bfields[::bloch[1], :] # normalise each magnetic field vector for i in range(len(Bfields)): norm = np.sqrt(Bfields[i, 0]**2 + Bfields[i, 1]**2 + Bfields[i, 2]**2) Bfields[i, 0] /= norm Bfields[i, 1] /= norm Bfields[i, 2] /= norm # extract x,y,z fields Bx = Bfields[:, 0] By = Bfields[:, 1] Bz = Bfields[:, 2] # define bloch object b = Bloch() b.add_points([Bx, By, Bz]) b.show() else: # plot fields fig, ax = plt.subplots(nrows=3, ncols=1, sharex=True, sharey=False) for i, row in enumerate(ax): # plot each component, skipping zero time value row.plot(time, Bfields[:, i]) row.set_title("Field vector along {} axis".format( ['x', 'y', 'z'][i])) plt.ylabel('Frequency (Hz)') plt.xlabel("Time (s)") #plt.ylabel("Ampltiude ($Hz/Gauss$)") plt.show()
def animate(states): fig = figure() ax = Axes3D(fig,azim=-40,elev=30) sphere = Bloch(axes=ax) def animate(i): sphere.clear() sphere.add_states([states[i]]) sphere.make_sphere() return ax def init(): sphere.vector_color = ['r'] return ax ani = animation.FuncAnimation(fig, animate, np.arange(len(states)), init_func=init, blit=False, repeat=True) ani.save('decoherence.mp4', fps=20)
def maj_vid(self, points): #takes screenshots of majorana stars over time to produce vid if points is None: points = [getStars(self.state)] i = 0 for p in points: bloch = Bloch(figsize=[9, 9]) bloch.xlabel = ['$<F_x>$', ''] bloch.ylabel = ['$<F_y>$', ''] bloch.zlabel = ['$<F_z>$', ''] bloch.point_color = ['g', 'r', 'b'] #ensures point and line are same colour bloch.point_marker = ['o', 'd', 'o'] bloch.add_points([p[0][0], p[1][0], p[2][0]]) bloch.add_points([p[0][1], p[1][1], p[2][1]]) bloch.add_points(p, meth='l') bloch.render(bloch.fig, bloch.axes) bloch.fig.savefig( "bloch" + str(i).zfill(int(np.ceil(np.log10(len(points))))) + ".png", dpi=600, transparent=False) i += 1
def draw_center_hvps_rectified_sphere(hv_points, root): b = Bloch() b.point_color = ['m', 'k', 'g', 'b', 'w', 'c', 'y', 'r'] b.zlabel = ['$z$', ''] b.point_marker = ['o'] b.point_size = [80] b.frame_width = 1.2 fig = plt.figure(figsize=(20, 20)) b.fig = fig x = (basis(2, 0) + (1 + 0j) * basis(2, 1)).unit() y = (basis(2, 0) + (0 + 1j) * basis(2, 1)).unit() z = (basis(2, 0) + (0 + 0j) * basis(2, 1)).unit() b.add_states([x, y, z]) for i in range(len(hv_points)): # Transform xyz to zxy coordinates tmp1 = np.array([hv_points[i][2], hv_points[i][0], hv_points[i][1]]) tmp2 = np.vstack([tmp1, -tmp1]).T tmp = tmp2 b.add_points(tmp) name = os.path.join(root, 'consensus_hvps_center_on_rectified_sphere.jpg') b.save(name=name)
def bloch_plot(self, points=None): """ Plot the current state on the Bloch sphere using qutip. """ if points is None: # convert current state into density operator rho = np.outer(self.state.H, self.state) # get Bloch vector representation points = self.get_bloch_vec(rho) # Can only plot systems of dimension 2 at this time assert len( points ) == 3, "System dimension must be spin 1/2 for Bloch sphere plot" # create instance of 3d plot bloch = Bloch(figsize=[9, 9]) # add state bloch.add_points(points) bloch.add_vectors([0, 0, 1]) bloch.render(bloch.fig, bloch.axes) bloch.fig.savefig("bloch.png", dpi=600, transparent=True) bloch.show()
def PlotBlochState(state): bsph = Bloch() bsph.add_vectors(StateToBloch(state)) return bsph.show()
def bloch_plot2(self, filename, save=False, vecList=[], vecColour=[], view=[190, 10], points=None, folder=False, fig=False, ax=False): """ Plot the current state on the Bloch sphere using qutip. """ if points is None: # convert current state into density operator rho = np.outer(self.state.H, self.state) # get Bloch vector representation points = self.get_bloch_vec(rho) # Can only plot systems of dimension 2 at this time assert len( points ) == 3, "System dimension must be spin 1/2 for Bloch sphere plot" # create instance of 3d plot if not fig or not ax: bloch = Bloch(figsize=[9, 9], view=view) else: bloch = Bloch(fig=fig, axes=ax, view=view) # add state bloch.add_points(points) # bloch.zlabel = [r'$\left|+z\right>$',r'$\left|-z\right>$'] bloch.zlabel = [r'$\ket{+_z}$', r'$\ket{-_z}$'] # bloch.ylabel = [r'$\ket{+_y}$',r'$\ket{-_y}$'] # bloch.ylabel = [r'$\ket{+_y}$',r'$\ket{-_y}$'] # print(vecList.shape) # add vectors if vecList.shape[1] == 3: if len(vecColour) >= vecList.shape[0] and len(vecColour) > 0: bloch.vector_color = vecColour else: bloch.vector_color = ['#CC6600', 'royalblue', 'r', 'm', 'g'] bloch.add_vectors(vecList) # add field vector # bloch.add_vectors([1,0,0.15]) # bloch.add_vectors([0,0,1]) # bloch.add_vectors([1,0,0]) # render bloch sphere if not fig or not ax: bloch.render() else: # bloch.render(fig = fig, axes = ax) bloch.render(fig=fig) # save output if save is True: if not folder: folder = 'C:/Users/Boundsy/Desktop/Uni Work/PHS2360/Sim Results/' print('Bloch plot saved to ' + str(folder)) path1 = folder + str(filename) + '.png' path2 = folder + str(filename) + '.pdf' bloch.fig.savefig(path1, dpi=800, transparent=True) bloch.fig.savefig(path2, dpi=800, transparent=True) # return axes for annotations return bloch.fig, bloch.axes
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Jul 30 12:26:48 2019 @author: banano """ # from qutip import Bloch, Bloch3d b1 = Bloch() vec = [0,1,0] b1.add_vectors(vec) b1.vector_color = ['k'] b2 = Bloch() vec = [0,0,1] b2.add_vectors(vec) b2.vector_color = ['r'] b2.show() b1.show()
def __init__(self, fig): ################################################################# # # Initialize plotting exact plots tools # ################################################################# # p = np.linspace(-20., 20., 1000)[:, np.newaxis] # q = np.linspace(-20., 20., 1000)[np.newaxis, :] # # self.hybrid = CAnalyticQCHybrid(p, q, kT=0.5) # # img_params = dict( # extent=[q.min(), q.max(), p.min(), p.max()], # origin='lower', # cmap='seismic', # # norm=WignerNormalize(vmin=-0.1, vmax=0.1) # norm=WignerSymLogNorm(linthresh=1e-10, vmin=-0.01, vmax=0.1) # ) p = np.linspace(-25, 25, 600)[:, np.newaxis] q = np.linspace(-25, 25, 600)[np.newaxis, :] self.hybrid = CAnalyticQCHybrid(p=p, q=q, omega=1., beta=2., alpha=0.95) img_params = dict( extent=[q.min(), q.max(), p.min(), p.max()], origin='lower', cmap='seismic', # norm=WignerNormalize(vmin=-0.1, vmax=0.1) norm=WignerSymLogNorm(linthresh=1e-10, vmin=-0.01, vmax=0.1)) ################################################################# # # Initialize Pauli propagator # ################################################################# self.pauli = SplitOpPauliLike1D( X_amplitude=2. * q.max(), X_gridDIM=512, dt=0.0001, K0="0.5 * P ** 2", V0="0.5 * X ** 2", V1="0.5 * 0.95 * X ** 2", # kT=self.hybrid.kT, # parameters controlling the width of the initial wavepacket ).set_wavefunction("exp(-0.5 * X ** 2)") ################################################################# # # Initialize plotting facility # ################################################################# self.fig = fig self.fig.suptitle( "Quantum-classical hybrid $m=1$, $\omega=1$, $\\alpha=0.95$, $\\beta={:.1e}$ (a.u.) (a.u.)" .format(self.hybrid.beta)) self.ax = fig.add_subplot(221) self.ax.set_title('Classical density') # generate empty plots self.img_classical_density = self.ax.imshow([[0]], **img_params) self.ax.set_xlabel('$q$ (a.u.)') self.ax.set_ylabel('$p$ (a.u.)') ax = fig.add_subplot(222) ax.set_title('Quantum purity') self.quantum_purity_plot, = ax.plot([0., 40], [1, 0.5], label='hybrid') self.pauli_quantum_purity_plot, = ax.plot([0., 40], [1, 0.5], label='Pauli') ax.set_xlabel('time (a.u.)') ax.set_ylabel("quantum purity") ax.legend() self.time = [] self.qpurity = [] self.pauli_qpurity = [] ax = fig.add_subplot(223) ax.set_title("Coordinate distribution") self.c_coordinate_distribution, = ax.semilogy( [self.hybrid.q.min(), self.hybrid.q.max()], [1e-11, 1e0], label="hybrid") self.pauli_coordinate_distribution, = ax.semilogy( [self.hybrid.q.min(), self.hybrid.q.max()], [1e-11, 1e0], label="Pauli") ax.legend() ax.set_xlabel('$q$ (a.u.)') ax.set_ylabel('Probability density') ax = fig.add_subplot(224, projection='3d', azim=90, elev=0) self.bloch = Bloch(axes=ax) self.bloch.make_sphere()
# ist qutip installiert? # https://numpy.org/install/#python-numpy-install-guide # importieren der numpy Library mit der Abkuerzung np # um nicht immer numpy schreiben zu muessen import numpy as np # importieren der Python eigene Mathematik Library import math # Beispielseite zu qutip # http://qutip.org/docs/3.1.0/guide/guide-bloch.html # %% -1- # Bloch() erzeugt eine Bloch # mit b verweisen wir spaeter auf diese b = Bloch() # b.show() zeigt die aktuelle Blochkugel an b.show() print('-1-') input('Press ENTER to continue.' ) # Ansonst wird Fenster sofort wieder geschlossen bzw. ueberschrieben. # %% -2- # hinzufuegen eines Vektor # x,y,z v = [1, 0, 0] # dazu geben wir einen Vektor in die x-Richtung an b.add_vectors( v) # mit b.add_vectors wird der Vektor v der Blochkugel hinzugefuegt b.show() print('-2-')
def __init__(self, fig): ################################################################# # # Initialize plotting exact plots tools # ################################################################# # p = np.linspace(-20., 20., 1000)[:, np.newaxis] # q = np.linspace(-20., 20., 1000)[np.newaxis, :] # # self.hybrid = CAnalyticQCHybrid(p, q, kT=0.5) # # img_params = dict( # extent=[q.min(), q.max(), p.min(), p.max()], # origin='lower', # cmap='seismic', # # norm=WignerNormalize(vmin=-0.1, vmax=0.1) # norm=WignerSymLogNorm(linthresh=1e-10, vmin=-0.01, vmax=0.1) # ) p = np.linspace(-0.1, 0.1, 500)[:, np.newaxis] q = np.linspace(-0.1, 0.1, 500)[np.newaxis, :] self.hybrid = SolAGKEq(p=p, q=q, omega=1., beta=1e5, alpha=0.95) img_params = dict( extent=[q.min(), q.max(), p.min(), p.max()], origin='lower', cmap='seismic', #norm=WignerNormalize(vmin=-0.1, vmax=0.1) norm=WignerSymLogNorm(linthresh=1e-10, vmin=-0.01, vmax=0.1)) # List to save the total hybrid energy for testing (it must be a conserved quantity) self.total_energy = [] # List to save the x component of the Bloch vector self.sigma_1 = [] ################################################################# # # Initialize plotting facility # ################################################################# self.fig = fig self.fig.suptitle( "Quantum-classical hybrid $m=1$, $\omega=1$, $\\alpha=0.95$, $\\beta={:.1e}$ (a.u.) (a.u.)" .format(self.hybrid.beta)) self.ax = fig.add_subplot(221) self.ax.set_title('Classical density') # generate empty plots self.img_classical_density = self.ax.imshow([[0]], **img_params) self.ax.set_xlabel('$q$ (a.u.)') self.ax.set_ylabel('$p$ (a.u.)') ax = fig.add_subplot(222) ax.set_title('Quantum purity') self.quantum_purity_plot, = ax.plot([0., 1000000], [1, 0.5]) ax.set_xlabel('time (a.u.)') ax.set_ylabel("quantum purity") self.time = [] self.qpurity = [] ax = fig.add_subplot(223) ax.set_title("Coordinate distribution") self.c_coordinate_distribution, = ax.semilogy( [self.hybrid.q.min(), self.hybrid.q.max()], [1e-11, 1e0], label="hybrid") ax.legend() ax.set_xlabel('$q$ (a.u.)') ax.set_ylabel('Probability density') ax = fig.add_subplot(224, projection='3d', azim=0, elev=0) self.bloch = Bloch(axes=ax) self.bloch.make_sphere()