Plotting

ERLabPy provides a number of plotting functions to help visualize data and create publication quality figures.

Importing

The key module to plotting is erlab.plotting, which contains various plotting functions. To import it, use the following code:

import matplotlib.pyplot as plt
import erlab.plotting as eplt
import erlab

First, let us generate some example data from a simple tight binding model of graphene. A rigid shift of 200 meV has been applied so that the Dirac cone is visible.

from erlab.io.exampledata import generate_data

dat = generate_data(bandshift=-0.2, seed=1).T

dat

<xarray.DataArray (eV: 300, ky: 250, kx: 250)> Size: 150MB
3.17 3.71 2.969 4.094 4.071 2.702 ... 0.02378 0.1156 0.1156 0.0235 0.0007165
Coordinates:
  * eV       (eV) float64 2kB -0.45 -0.4482 -0.4464 ... 0.08639 0.08819 0.09
  * ky       (ky) float64 2kB -0.89 -0.8829 -0.8757 ... 0.8757 0.8829 0.89
  * kx       (kx) float64 2kB -0.89 -0.8829 -0.8757 ... 0.8757 0.8829 0.89

xarray.DataArray

• eV: 300
• ky: 250
• kx: 250

• 3.17 3.71 2.969 4.094 4.071 ... 0.02378 0.1156 0.1156 0.0235 0.0007165

  array([[[3.16988000e+00, 3.70981552e+00, 2.96864224e+00, ...,
           4.77441778e+00, 2.68780734e+00, 3.58014595e+00],
          [3.11472181e+00, 4.99662991e+00, 4.33036264e+00, ...,
           4.14316680e+00, 2.51227236e+00, 2.86280882e+00],
          [4.20805285e+00, 5.11327317e+00, 4.61750090e+00, ...,
           3.48265432e+00, 3.11414840e+00, 2.25097081e+00],
          ...,
          [6.78462033e+00, 5.72291886e+00, 4.72469251e+00, ...,
           2.79661715e+00, 3.92313953e+00, 3.66758190e+00],
          [4.35915511e+00, 4.90442132e+00, 3.74273234e+00, ...,
           2.95530884e+00, 5.28886388e+00, 5.24115485e+00],
          [4.33768324e+00, 3.47113544e+00, 2.55882867e+00, ...,
           2.93477333e+00, 5.33625560e+00, 7.91872470e+00]],
  
         [[3.55132863e+00, 3.38371741e+00, 2.84406026e+00, ...,
           3.69613211e+00, 3.93494449e+00, 4.19966501e+00],
          [2.47746428e+00, 3.71616202e+00, 4.81859481e+00, ...,
           3.46830901e+00, 3.92669279e+00, 4.37095141e+00],
          [3.35680809e+00, 3.58224642e+00, 4.64347774e+00, ...,
           2.94637355e+00, 4.10706201e+00, 3.75000791e+00],
  ...
           6.93990816e-03, 5.24098590e-03, 2.27311413e-02],
          [5.10658278e-03, 1.91810304e-02, 2.79012144e-02, ...,
           9.28219325e-02, 3.72252576e-02, 9.14126278e-02],
          [7.44505241e-05, 6.53480462e-04, 2.34407666e-02, ...,
           3.70198064e-01, 9.58749828e-02, 2.44888315e-02]],
  
         [[3.53356451e-03, 2.27695745e-01, 9.13149099e-01, ...,
           7.00876446e-02, 2.32873892e-01, 2.78236113e-01],
          [7.21992044e-04, 4.65028451e-02, 1.86489496e-01, ...,
           1.05797035e-01, 4.13523732e-01, 1.49476809e-01],
          [7.21312930e-04, 2.48403636e-02, 9.43059870e-02, ...,
           4.29708001e-02, 1.72646211e-01, 6.79042692e-02],
          ...,
          [2.06386786e-01, 3.89175368e-01, 1.33661244e-01, ...,
           2.32977441e-02, 5.66623178e-04, 3.55179865e-04],
          [2.48401658e-02, 9.19184247e-02, 5.08321046e-02, ...,
           1.09886317e-01, 6.37623966e-03, 1.48810240e-03],
          [3.61495409e-04, 3.18070344e-03, 1.14273325e-01, ...,
           1.15613895e-01, 2.35049226e-02, 7.16525028e-04]]],
        shape=(300, 250, 250))

• Coordinates: (3)
  • eV
    (eV)
    float64
    -0.45 -0.4482 ... 0.08819 0.09

    array([-0.45    , -0.448194, -0.446388, ...,  0.086388,  0.088194,  0.09    ],
          shape=(300,))

  • ky
    (ky)
    float64
    -0.89 -0.8829 ... 0.8829 0.89

    array([-0.89    , -0.882851, -0.875703, ...,  0.875703,  0.882851,  0.89    ],
          shape=(250,))

  • kx
    (kx)
    float64
    -0.89 -0.8829 ... 0.8829 0.89

    array([-0.89    , -0.882851, -0.875703, ...,  0.875703,  0.882851,  0.89    ],
          shape=(250,))

We can see that the generated data is a three-dimensional xarray.DataArray. Now, let’s extract a cut along \(k_y = 0.3\).

cut = dat.qsel(ky=0.3)
cut

<xarray.DataArray (eV: 300, kx: 250)> Size: 600kB
3.52 2.469 3.126 3.968 2.827 2.746 ... 0.1384 0.05118 0.09941 0.1574 0.5755
Coordinates:
  * eV       (eV) float64 2kB -0.45 -0.4482 -0.4464 ... 0.08639 0.08819 0.09
  * kx       (kx) float64 2kB -0.89 -0.8829 -0.8757 ... 0.8757 0.8829 0.89
    ky       float64 8B 0.2967

xarray.DataArray

• eV: 300
• kx: 250

• 3.52 2.469 3.126 3.968 2.827 ... 0.1384 0.05118 0.09941 0.1574 0.5755

  array([[3.51996103, 2.46860004, 3.12627143, ..., 3.63247043, 3.19189828,
          2.56384799],
         [1.99131562, 2.44728588, 3.13024957, ..., 3.35094604, 2.36664741,
          1.60045821],
         [1.8102282 , 2.42394519, 3.25970425, ..., 2.7023653 , 1.66755731,
          1.63550534],
         ...,
         [0.00580997, 0.09148465, 0.2993771 , ..., 0.01552326, 0.03751128,
          0.01112317],
         [0.02342888, 0.10960098, 0.09828399, ..., 0.03836185, 0.10246751,
          0.13451497],
         [0.02775587, 0.1098784 , 0.02903789, ..., 0.09941059, 0.15744388,
          0.57552933]], shape=(300, 250))

• Coordinates: (3)
  • eV
    (eV)
    float64
    -0.45 -0.4482 ... 0.08819 0.09

    array([-0.45    , -0.448194, -0.446388, ...,  0.086388,  0.088194,  0.09    ],
          shape=(300,))

  • kx
    (kx)
    float64
    -0.89 -0.8829 ... 0.8829 0.89

    array([-0.89    , -0.882851, -0.875703, ...,  0.875703,  0.882851,  0.89    ],
          shape=(250,))

  • ky
    ()
    float64
    0.2967

    array(0.29666667)

Plotting 2D data

The fastest way to plot a 2D array like this is to use plot_array. Each axis is automatically labeled.

eplt.plot_array(cut)

<matplotlib.image.AxesImage at 0x7b116e921be0>

plot_array takes many arguments that can customize the look of your plot. The following is an example of some of the functionality provided. For all arguments, see the API reference.

eplt.plot_array(
    cut, cmap="Greys", gamma=0.5, colorbar=True, colorbar_kw=dict(width=10, ticks=[])
)

<matplotlib.image.AxesImage at 0x7b116dce7250>

plot_array can also be accessed (for 2D data) through xarray.DataArray.qplot().

cut.qplot(cmap="Greys", gamma=0.5)

<matplotlib.image.AxesImage at 0x7b116dbcead0>

Next, let’s add some annotations! The following code adds a line indicating the Fermi level and adds a colorbar. Here, unlike the previous example, the colorbar was added after plotting. Like this, adding elements separately instead of using keyword arguments can make the code more readable in complex plots.

eplt.plot_array(cut, cmap="Greys", gamma=0.5)

eplt.fermiline(linewidth=1, linestyle="--")
eplt.nice_colorbar(width=10, ticks=[])

<matplotlib.colorbar.Colorbar at 0x7b116c226c10>

You will read more about various annotations later in this document.

Slices of higher-dimensional data

What if we want to plot multiple slices at once? We should create subplots to place the slices. plt.subplots is very useful in managing multiple axes and figures. If you are unfamiliar with the syntax, visit the relevant matplotlib documentation.

Suppose we want to plot constant energy surfaces at specific binding energies, say, at [-0.4, -0.2, 0.0]. We could create three subplots and iterate over the axes.

energies = [-0.4, -0.2, 0.0]

fig, axs = plt.subplots(1, 3, layout="compressed", sharey=True)
for energy, ax in zip(energies, axs):
    const_energy_surface = dat.qsel(eV=energy)
    eplt.plot_array(const_energy_surface, ax=ax, gamma=0.5, aspect="equal")

Here, we plotted each constant energy surface with plot_array.

To remove the duplicated y axis labels and add some annotations, we can use clean_labels and label_subplot_properties:

fig, axs = plt.subplots(1, 3, layout="compressed", sharey=True)
for energy, ax in zip(energies, axs):
    const_energy_surface = dat.qsel(eV=energy)
    eplt.plot_array(const_energy_surface, ax=ax, gamma=0.5, aspect="equal")

eplt.clean_labels(axs)  # removes shared y labels
eplt.label_subplot_properties(axs, values={"Eb": energies})  # annotates energy

Not bad. However, when it gets to multiple slices along multiple datasets, it gets cumbersome.

Luckily, ERLabPy provides a function that automates the subplot creation, slicing, and annotation for you: plot_slices, which reduces the same code to a one-liner.

fig, axs = eplt.plot_slices([dat], eV=[-0.4, -0.2, 0.0], gamma=0.5, axis="image")

We can also plot the data integrated over an energy window, in this case with a width of 200 meV by adding the eV_width argument:

fig, axs = eplt.plot_slices(
    [dat], eV=[-0.4, -0.2, 0.0], eV_width=0.2, gamma=0.5, axis="image"
)

Cuts along constant \(k_y\) can be plotted analogously.

fig, axs = eplt.plot_slices([dat], ky=[0.0, 0.1, 0.3], gamma=0.5, figsize=(6, 2))

Here, we notice that the first two plots slices through regions with less spectral weight, so the color across the three subplots are not on the same scale. This may be misleading in some occasions where intensity across different slices are important. Luckily, we have a function that can unify the color limits across multiple axes.

Note

The same effect can be achieved by passing on same_limits=True to plot_slices.

fig, axs = eplt.plot_slices([dat], ky=[0.0, 0.1, 0.3], gamma=0.5, figsize=(6, 2))
eplt.unify_clim(axs)

We can also choose a reference axis to get the color limits from.

fig, axs = eplt.plot_slices([dat], ky=[0.0, 0.1, 0.3], gamma=0.5, figsize=(6, 2))
eplt.unify_clim(axs, target=axs.flat[1])

What if we want to plot constant energy surfaces and cuts in the same figure? We can create the subplots first and then utilize the axes argument of plot_slices.

fig, axs = plt.subplots(2, 3, layout="compressed", sharex=True, sharey="row")
eplt.plot_slices([dat], eV=[-0.4, -0.2, 0.0], gamma=0.5, axes=axs[0, :], axis="image")
eplt.plot_slices([dat], ky=[0.0, 0.1, 0.3], gamma=0.5, axes=axs[1, :])
eplt.clean_labels(axs)

Annotations

ERLabPy provides a number of functions to annotate your plots. Some of the most frequently used functions were already used in the previous examples, such as fermiline and label_subplot_properties. Here, we will go through some of the other functions that can be used to annotate your plots.

Labeling subplots

You can give an alphanumeric label to each subplot using label_subplots:

fig, axs = eplt.plot_slices(
    [dat], ky=[0.0, 0.1, 0.3], figsize=(6, 2), cmap="Greys", annotate=False
)

eplt.label_subplots(axs, prefix="(", suffix=")")

The labels can be customized with different arguments, such as prefix, suffix, fontsize, pad, and more. See label_subplots for all available arguments.

Labeling high symmetry points

There are many ways to label high symmetry points along cuts. The simplest way is to use mark_points:

fig, ax = plt.subplots(figsize=(3.4, 2.1))
dat.qsel(kx=0).qplot(ax=ax)

eplt.mark_points([-0.6, 0, 0.6], ["K", "G", "K"], y=0.02)

Providing a y value larger than the maximum of the data will place the labels above the plot. If you want to place the labels at a specific position, you can provide a sequence of y values.

fig, ax = plt.subplots(figsize=(3.4, 2.1))
dat.qsel(kx=0).qplot(ax=ax)

eplt.mark_points([-0.6, 0, 0.6], ["K", "G", "K"], y=[0.12, 0.12, 0.02])

Note how the label colors are automatically set to stand out against the background. This is done by default, but you can also set the colors manually with the color argument.

You can also add an arrow between the points with matplotlib.patches.FancyArrowPatch:

import matplotlib.patches as mpatches

fig, ax = plt.subplots(figsize=(3.4, 2.1))
dat.qsel(kx=0).qplot(ax=ax)

eplt.mark_points([-0.6, 0, 0.6], ["K", "G", "K"], y=0.02)

ax.add_patch(
    mpatches.FancyArrowPatch(
        (0, 0.045),
        (0.6, 0.045),
        arrowstyle=mpatches.ArrowStyle(
            "Simple", head_length=4, head_width=2, tail_width=0.25
        ),
        shrinkA=5,
        shrinkB=5,
        color="w",
        lw=0.0,
        clip_on=False,
    )
)

<matplotlib.patches.FancyArrowPatch at 0x7b116ddf9d30>

Setting multiple titles and axis labels

You can set titles and axis labels for multiple axes at once using set_titles, set_xlabels, and set_ylabels. These functions take a list of strings as input, which will be applied to the respective axes.

fig, axs = plt.subplots(1, 2, figsize=(3.4, 2.1), layout="compressed")

eplt.set_titles(axs, ["Left title", "Right title"])
eplt.set_xlabels(axs, ["Left x label", "Right x label"])
eplt.set_ylabels(axs, ["Left y label", "Right y label"])

Scaling axis units

Consider a 2D cut of a 3D dataset, where the energy axis is in eV. Suppose you want to convert the energy axis from eV to meV. You can use scale_units to scale the axis units:

fig, ax = plt.subplots(figsize=(3.4, 2.1))
cut.qplot(ax=ax)

eplt.scale_units(ax, "y", si=-3)

An exponent of -3 has been used to convert eV to meV, and the label has been updated accordingly with the corresponding SI prefix.

Brillouin zones

You can plot Brillouin zones (BZs) sliced along arbitrary planes in k-space using the helper functions in erlab.lattice.

import matplotlib.pyplot as plt
import numpy as np
import erlab
import erlab.plotting as eplt

Plotting a 2D Brillouin zone

The most simple task is to plot a 2D in-plane BZ slice. Here, we define a hexagonal lattice with lattice parameters \(a = b = 3.0\) Å, \(c = 5.0\) Å, and angles \(\alpha = 90^\circ\), \(\beta = 90^\circ\), and \(\gamma = 120^\circ\). For this, we can use eplt.plot_bz, which takes the upper 2 × 2 part of the lattice vectors and plots the in-plane BZ as a polygon.

avec = erlab.lattice.abc2avec(3.0, 3.0, 5.0, 90.0, 90.0, 120.0)

fig, ax = plt.subplots(figsize=(2, 2))
eplt.plot_bz(avec, ax=ax)
ax.set(
    xlabel=r"$k_x$ (Å$^{-1}$)",
    ylabel=r"$k_y$ (Å$^{-1}$)",
    xlim=(-1.5, 1.5),
    ylim=(-1.5, 1.5),
    aspect="equal",
)

[Text(0.5, 0, '$k_x$ (Å$^{-1}$)'),
 Text(0, 0.5, '$k_y$ (Å$^{-1}$)'),
 (-1.5, 1.5),
 (-1.5, 1.5),
 None]

Plotting arbitrary Brillouin zone slices

Three dimensional Brillouin zones often need more general slicing.

The most general function is erlab.lattice.get_bz_slice(), which takes the full 3 × 3 reciprocal lattice vectors and a plane definition in k-space and returns the BZ edges sliced by that plane.

However, we usually slice along constant \(k_z\) or \(k_x\) (or \(k_y\)) planes. For these common cases, erlab.lattice.get_in_plane_bz() and erlab.lattice.get_out_of_plane_bz() are provided for convenience.

Let’s consider a face-centered orthorhombic (\(Fmmm\)) crystal with lattice parameters \(a = 6.0\) Å, \(b = 10.0\) Å, and \(c = 25.0\) Å. The lattice vectors are given by:

avec = erlab.lattice.abc2avec(6.0, 10.0, 25.0, 90.0, 90.0, 90.0)

Next, we convert the lattice vectors to primitive ones for the face-centered orthorhombic lattice and obtain the reciprocal lattice vectors:

avec_p = erlab.lattice.to_primitive(avec, centering_type="F")
bvec = erlab.lattice.to_reciprocal(avec_p)

We plot the in-plane BZ for \(k_z=0.2~\mathrm{Å}^{-1}\) by using erlab.lattice.get_in_plane_bz():

segments, vertices = erlab.lattice.get_in_plane_bz(
    bvec, kz=0.2, angle=60.0, bounds=(-1.5, 1.5, -1.5, 1.5)
)

fig, ax = plt.subplots(figsize=(2.5, 2.5))

for seg in segments:
    ax.plot(seg[:, 0], seg[:, 1], color="tab:purple", lw=1.5)

ax.scatter(vertices[:, 0], vertices[:, 1], s=20, c="tab:purple")
ax.set(xlabel=r"$k_x$ (Å$^{-1}$)", ylabel=r"$k_y$ (Å$^{-1}$)", aspect="equal")

[Text(0.5, 0, '$k_x$ (Å$^{-1}$)'), Text(0, 0.5, '$k_y$ (Å$^{-1}$)'), None]

We can also plot the out-of-plane BZ along \(k_y = 0\) using erlab.lattice.get_out_of_plane_bz():

segments, vertices = erlab.lattice.get_out_of_plane_bz(
    bvec, k_parallel=0.0, angle=60.0, bounds=(-1.5, 1.5, -1.5, 1.5)
)

fig, ax = plt.subplots(figsize=(2.5, 2.5))

for seg in segments:
    ax.plot(seg[:, 0], seg[:, 1], color="tab:purple", lw=1.5)

ax.scatter(vertices[:, 0], vertices[:, 1], s=20, c="tab:purple")
ax.set(xlabel=r"$k_x$ (Å$^{-1}$)", ylabel=r"$k_z$ (Å$^{-1}$)", aspect="equal")

[Text(0.5, 0, '$k_x$ (Å$^{-1}$)'), Text(0, 0.5, '$k_z$ (Å$^{-1}$)'), None]

2D colormaps

2D colormaps are a method to visualize two data with a single image by mapping one of the data to the lightness of the color and the other to the hue. This is useful when visualizing dichroic or spin-resolved ARPES data[Tusche et al., 2015].

Let us begin with the simulated constant energy contours of Graphene, 0.3 eV below and above the Fermi level.

dat0, dat1 = generate_data(
    shape=(250, 250, 2), Erange=(-0.3, 0.3), temp=0.0, seed=1, count=1e6
).T

_, axs = eplt.plot_slices(
    [dat0, dat1],
    order="F",
    subplot_kw={"layout": "compressed", "sharey": "row"},
    axis="scaled",
    label=True,
)

Suppose we want to visualize the sum and the normalized difference between the two. The simplest way is to plot them side by side.

dat_sum = dat0 + dat1
dat_ndiff = (dat0 - dat1) / dat_sum

fig, axs = eplt.plot_slices(
    [dat_sum, dat_ndiff],
    order="F",
    subplot_kw={"layout": "compressed", "sharey": "row"},
    cmap=["viridis", "bwr"],
    axis="scaled",
)
eplt.proportional_colorbar()
eplt.set_titles(axs, ["Sum", "Normalized difference"])

The difference array is noisy for small values of the sum. We can plot using a 2D colomap, where dat_ndiff is mapped to the color along the colormap and dat_sum is mapped to the lightness of the colormap.

eplt.plot_array_2d(dat_sum, dat_ndiff)

(<matplotlib.image.AxesImage at 0x7b1166e22d50>,
 <matplotlib.colorbar.Colorbar at 0x7b1166e22710>)

The color normalization for each axis can be set independently with lnorm and cnorm. The appearance of the colorbar axes can be customized with the returned Colorbar object.

_, cb = eplt.plot_array_2d(
    dat_sum,
    dat_ndiff,
    lnorm=eplt.InversePowerNorm(0.5),
    cnorm=eplt.CenteredInversePowerNorm(0.7, vcenter=0.0, halfrange=1.0),
)
cb.ax.set_xticks(cb.ax.get_xlim())
cb.ax.set_xticklabels(["Min", "Max"])

[Text(0.0, 0, 'Min'), Text(41.33577630506462, 0, 'Max')]

Styling figures

You can control the look and feel of matplotlib figures with style sheets and rcParams. In addition to the options provided by matplotlib, ERLabPy provides some style sheets that are listed below. Note that style sheets that change the default font requires the font to be installed on the system. To see how each one looks, try running the code provided by matplotlib.

Style Name	Description
khan	Personal preferences of the package author.
fira	Changes the default font to Fira Sans.
firalight	Changes the default font to Fira Sans Light.
times	Changes the default font to Times New Roman.
nature	Changes the default font to Arial, and tweaks some aspects such as padding and default figure size.

with plt.style.context(["nature"]):
    eplt.plot_array(cut, cmap="Greys", gamma=0.5)

Tips

• In the python ecosystem, there are some libraries that provide great colormaps, such as cmasher, cmocean, colorcet, and cmcrameri.

• Although matplotlib is a powerful library, it is heavy and slow, and better suited for static plots. For interactive plots, libraries such as Plotly or Bokeh are popular.

  The hvplot library is a high-level plotting library that provides a simple interface to Bokeh, Plotly, and Matplotlib. It is particularly useful for interactive plots and can be used with xarray objects. Here are some examples that uses the Bokeh backend:

import hvplot.xarray

cut.hvplot(x="kx", y="eV", cmap="Greys", aspect=1.5)

dat.hvplot(x="kx", y="ky", cmap="Greys", aspect="equal", widget_location="bottom")

Note

If you are viewing this documentation online, the slider above will not work. To see the interactive plot, you can run the notebook locally after installing hvplot.

For more information, see the hvplot documentation.

Miscellaneous

Some functions that do not fit into the above categories, but are useful nonetheless.

Copying equations as svg files

Matplotlib includes its own text parser to plot equations and text. By exploiting this, you can copy equations and text as svg files and paste them into vector graphics applications such as Adobe Illustrator or Inkscape. This is done with copy_mathtext:

eplt.copy_mathtext(r"$e^{i\pi} + 1 = 0$")

'<?xml version="1.0" encoding="utf-8" standalone="no"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"\n  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="51pt" height="11pt" viewBox="0 0 51 11" xmlns="http://www.w3.org/2000/svg" version="1.1">\n <metadata>\n  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">\n   <cc:Work>\n    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>\n    <dc:date>2026-05-31T23:10:16.216360</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.10.9, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id="figure_1">\n  <g id="patch_1">\n   <path d="M 0 11 \nL 51 11 \nL 51 0 \nL 0 0 \nL 0 11 \nz\n" style="fill: none"/>\n  </g>\n  <g id="text_1">\n   <!-- $e^{i\\pi} + 1 = 0$ -->\n   <g transform="translate(0 10)">\n    <text>\n     <tspan x="0" y="-0.85625" style="font-style: oblique; font-size: 10px; font-family: \'DejaVu Sans\'">e</tspan>\n     <tspan x="6.616458" y="-4.684375" style="font-style: oblique; font-size: 7px; font-family: \'DejaVu Sans\'">i</tspan>\n     <tspan x="8.561283" y="-4.684375" style="font-style: oblique; font-size: 7px; font-family: \'DejaVu Sans\'">π</tspan>\n     <tspan x="14.997318" y="-0.85625" style="font-size: 10px; font-family: \'DejaVu Sans\'">+</tspan>\n     <tspan x="25.324466" y="-0.85625" style="font-size: 10px; font-family: \'DejaVu Sans\'">1</tspan>\n     <tspan x="33.635013" y="-0.85625" style="font-size: 10px; font-family: \'DejaVu Sans\'">=</tspan>\n     <tspan x="43.962161" y="-0.85625" style="font-size: 10px; font-family: \'DejaVu Sans\'">0</tspan>\n    </text>\n   </g>\n  </g>\n </g>\n</svg>\n'