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 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, 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 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 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_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 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 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 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 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 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 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