Plotting on the Bloch Sphere¶

Introduction¶

When studying the dynamics of a two-level system, it is often convent to visualize the state of the system by plotting the state-vector or density matrix on the Bloch sphere. In QuTiP, we have created two different classes to allow for easy creation and manipulation of data sets, both vectors and data points, on the Bloch sphere. The qutip.Bloch class, uses Matplotlib to render the Bloch sphere, where as qutip.Bloch3d uses the Mayavi rendering engine to generate a more faithful 3D reconstruction of the Bloch sphere.

The Bloch and Bloch3d Classes¶

In QuTiP, creating a Bloch sphere is accomplished by calling either:

In [1]: b = Bloch()

which will load an instance of the qutip.Bloch class, or using:

>>> b3d = Bloch3d()

that loads the qutip.Bloch3d version. Before getting into the details of these objects, we can simply plot the blank Bloch sphere associated with these instances via:

In [2]: b.show()

or

In addition to the show() command, the Bloch class has the following functions:

As an example, we can add a single data point:

In [3]: pnt = [1/np.sqrt(3),1/np.sqrt(3),1/np.sqrt(3)]

In [4]: b.add_points(pnt)

In [5]: b.show()
<Figure size 500x500 with 1 Axes>

and then a single vector:

In [6]: vec = [0,1,0]

In [7]: b.add_vectors(vec)

In [8]: b.show()
<Figure size 500x500 with 1 Axes>

and then add another vector corresponding to the \(\left|\rm up \right>\) state:

In [9]: up = basis(2,0)

In [10]: b.add_states(up)

In [11]: b.show()
<Figure size 500x500 with 1 Axes>

Notice that when we add more than a single vector (or data point), a different color will automatically be applied to the later data set (mod 4). In total, the code for constructing our Bloch sphere with one vector, one state, and a single data point is:

In [12]: b = Bloch()

In [13]: pnt = [1./np.sqrt(3), 1./np.sqrt(3), 1./np.sqrt(3)]

In [14]: b.add_points(pnt)

In [15]: vec = [0,1,0]

In [16]: b.add_vectors(vec)

In [17]: up = basis(2,0)

In [18]: b.add_states(up)

In [19]: b.show()

where we have removed the extra show() commands. Replacing b=Bloch() with b=Bloch3d() in the above code generates the following 3D Bloch sphere.

We can also plot multiple points, vectors, and states at the same time by passing list or arrays instead of individual elements. Before giving an example, we can use the clear() command to remove the current data from our Bloch sphere instead of creating a new instance:

In [20]: b.clear()

In [21]: b.show()
<Figure size 500x500 with 1 Axes>

Now on the same Bloch sphere, we can plot the three states associated with the x, y, and z directions:

In [22]: x = (basis(2,0)+(1+0j)*basis(2,1)).unit()

In [23]: y = (basis(2,0)+(0+1j)*basis(2,1)).unit()

In [24]: z = (basis(2,0)+(0+0j)*basis(2,1)).unit()

In [25]: b.add_states([x,y,z])

In [26]: b.show()
<Figure size 500x500 with 1 Axes>

a similar method works for adding vectors:

In [27]: b.clear()

In [28]: vec = [[1,0,0],[0,1,0],[0,0,1]]

In [29]: b.add_vectors(vec)

In [30]: b.show()
<Figure size 500x500 with 1 Axes>

Adding multiple points to the Bloch sphere works slightly differently than adding multiple states or vectors. For example, lets add a set of 20 points around the equator (after calling clear()):

In [31]: xp = [np.cos(th) for th in np.linspace(0, 2*pi, 20)]

In [32]: yp = [np.sin(th) for th in np.linspace(0, 2*pi, 20)]

In [33]: zp = np.zeros(20)

In [34]: pnts = [xp, yp, zp]

In [35]: b.add_points(pnts)

In [36]: b.show()
<Figure size 500x500 with 1 Axes>

Notice that, in contrast to states or vectors, each point remains the same color as the initial point. This is because adding multiple data points using the add_points function is interpreted, by default, to correspond to a single data point (single qubit state) plotted at different times. This is very useful when visualizing the dynamics of a qubit. An example of this is given in the example . If we want to plot additional qubit states we can call additional add_points functions:

In [37]: xz = np.zeros(20)

In [38]: yz = [np.sin(th) for th in np.linspace(0, pi, 20)]

In [39]: zz = [np.cos(th) for th in np.linspace(0, pi, 20)]

In [40]: b.add_points([xz, yz, zz])

In [41]: b.show()
<Figure size 500x500 with 1 Axes>

The color and shape of the data points is varied automatically by the Bloch class. Notice how the color and point markers change for each set of data. Again, we have had to call add_points twice because adding more than one set of multiple data points is not supported by the add_points function.

What if we want to vary the color of our points. We can tell the qutip.Bloch class to vary the color of each point according to the colors listed in the b.point_color list (see Configuring the Bloch sphere below). Again after clear():

In [42]: xp = [np.cos(th) for th in np.linspace(0, 2*pi, 20)]

In [43]: yp = [sin(th) for th in np.linspace(0, 2*pi, 20)]

In [44]: zp = np.zeros(20)

In [45]: pnts = [xp, yp, zp]

In [46]: b.add_points(pnts,'m') # <-- add a 'm' string to signify 'multi' colored points

In [47]: b.show()
<Figure size 500x500 with 1 Axes>

Now, the data points cycle through a variety of predefined colors. Now lets add another set of points, but this time we want the set to be a single color, representing say a qubit going from the \(\left|\rm up\right>\) state to the \(\left|\rm down\right>\) state in the y-z plane:

In [48]: xz = np.zeros(20)

In [49]: yz = [np.sin(th) for th in np.linspace(0, pi ,20)]

In [50]: zz = [np.cos(th) for th in np.linspace(0, pi, 20)]

In [51]: b.add_points([xz, yz, zz]) # no 'm'

In [52]: b.show()
<Figure size 500x500 with 1 Axes>

Again, the same plot can be generated using the qutip.Bloch3d class by replacing Bloch with Bloch3d:

A more slick way of using this ‘multi’ color feature is also given in the example, where we set the color of the markers as a function of time.

Configuring the Bloch sphere¶

In [53]: b = Bloch()

In [54]: print(b)
Bloch data:
-----------
Number of points:  0
Number of vectors: 0

Bloch sphere properties:
------------------------
font_color:      black
font_size:       20
frame_alpha:     0.2
frame_color:     gray
frame_width:     1
point_color:     ['b', 'r', 'g', '#CC6600']
point_marker:    ['o', 's', 'd', '^']
point_size:      [25, 32, 35, 45]
sphere_alpha:    0.2
sphere_color:    #FFDDDD
figsize:         [5, 5]
vector_color:    ['g', '#CC6600', 'b', 'r']
vector_width:    3
vector_style:    -|>
vector_mutation: 20
view:            [-60, 30]
xlabel:          ['$x$', '']
xlpos:           [1.2, -1.2]
ylabel:          ['$y$', '']
ylpos:           [1.2, -1.2]
zlabel:          ['$\\left|0\\right>$', '$\\left|1\\right>$']
zlpos:           [1.2, -1.2]

Animating with the Bloch sphere¶

The Bloch class was designed from the outset to generate animations. To animate a set of vectors or data points the basic idea is: plot the data at time t1, save the sphere, clear the sphere, plot data at t2,… The Bloch sphere will automatically number the output file based on how many times the object has been saved (this is stored in b.savenum). The easiest way to animate data on the Bloch sphere is to use the save() method and generate a series of images to convert into an animation. However, as of Matplotlib version 1.1, creating animations is built-in. We will demonstrate both methods by looking at the decay of a qubit on the bloch sphere.

from qutip import *
from scipy import *
def qubit_integrate(w, theta, gamma1, gamma2, psi0, tlist):
    # operators and the hamiltonian
    sx = sigmax(); sy = sigmay(); sz = sigmaz(); sm = sigmam()
    H = w * (cos(theta) * sz + sin(theta) * sx)
    # collapse operators
    c_op_list = []
    n_th = 0.5 # temperature
    rate = gamma1 * (n_th + 1)
    if rate > 0.0: c_op_list.append(sqrt(rate) * sm)
    rate = gamma1 * n_th
    if rate > 0.0: c_op_list.append(sqrt(rate) * sm.dag())
    rate = gamma2
    if rate > 0.0: c_op_list.append(sqrt(rate) * sz)


    # evolve and calculate expectation values
    output = mesolve(H, psi0, tlist, c_op_list, [sx, sy, sz])  
    return output.expect[0], output.expect[1], output.expect[2]
    
## calculate the dynamics
w     = 1.0 * 2 * pi   # qubit angular frequency
theta = 0.2 * pi       # qubit angle from sigma_z axis (toward sigma_x axis)
gamma1 = 0.5      # qubit relaxation rate
gamma2 = 0.2      # qubit dephasing rate
# initial state
a = 1.0
psi0 = (a* basis(2,0) + (1-a)*basis(2,1))/(sqrt(a**2 + (1-a)**2))
tlist = linspace(0,4,250)
#expectation values for ploting
sx, sy, sz = qubit_integrate(w, theta, gamma1, gamma2, psi0, tlist)

import numpy as np
b = Bloch()
b.vector_color = ['r']
b.view = [-40,30]
for i in range(len(sx)):
    b.clear()
    b.add_vectors([np.sin(theta),0,np.cos(theta)])
    b.add_points([sx[:i+1],sy[:i+1],sz[:i+1]])
    b.save(dirc='temp') #saving images to temp directory in current working directory

ffmpeg -r 20 -b 1800 -i bloch_%01d.png bloch.mp4

from pylab import *
import matplotlib.animation as animation
from mpl_toolkits.mplot3d import Axes3D

fig = figure()
ax = Axes3D(fig,azim=-40,elev=30)
sphere = Bloch(axes=ax)

def animate(i):
    sphere.clear()
    sphere.add_vectors([np.sin(theta),0,np.cos(theta)])
    sphere.add_points([sx[:i+1],sy[:i+1],sz[:i+1]])
    sphere.make_sphere()
    return ax

def init():
    sphere.vector_color = ['r']
    return ax

ani = animation.FuncAnimation(fig, animate, np.arange(len(sx)),
                            init_func=init, blit=True, repeat=False)
ani.save('bloch_sphere.mp4', fps=20)