surface-ion 1.0.1__tar.gz

surface-ion-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 underforestaaa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

surface-ion-1.0.1/MANIFEST.in

@@ -0,0 +1,7 @@
+include readme.md
+
+recursive-include tests *
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+
+recursive-include docs *.rst conf.py Makefile make.bat *.jpg *.png *.gif

surface-ion-1.0.1/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: surface-ion
+Version: 1.0.1
+Summary: Python package for simulation and analysis of ion crystals in surface traps.
+Author: Artem Podlesnyy
+Author-email: a.podlesnyy@rqc.ru
+License: MIT license
+Keywords: surface trap,ion,quantum computing,ion simulation,normal modes,mathieu modes,ion shuttling,voltage optimization
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.6
+License-File: LICENSE
+Requires-Dist: numpy>=1.13.3
+Requires-Dist: jinja2>=2.9.6
+Requires-Dist: scipy>=1.12.1
+Requires-Dist: scikit-optimize>=0.10.2
+Requires-Dist: electrode>=1.4
+Requires-Dist: matplotlib>=3.9.2
+Requires-Dist: gdspy>=1.6.13
+Requires-Dist: shapely>=2.0.6
+Requires-Dist: tqdm>=4.66.6
+Requires-Dist: wexpect
+
+# *Sion* package
+
+Python package for simulation and analysis of ion crystals in surface electrode traps.
+
+## Installation
+
+To use *Sion*, the following packages are required to be installed from source and tested:
+- [pylion package](https://bitbucket.org/dtrypogeorgos/pylion/src/master/): LAMMPS wrapper for ion dynamics simulation. This package requires installation of LAMMPS software with the specific version. It will work well with the latest LAMMPS version, if in source file *pylion.py* at line 51 you change "lmp_serial" to "lmp".  
+- [electrode package](https://github.com/nist-ionstorage/electrode): Python package for convenient definition and analysis of surface electrode traps.  
+!Note: for correct execution of these packages, numpy<=1.21.0 is recquired. Alternatively one may install 
+
+The newest version may be installed via pip:  
+<code>pip install surface-ion</code>
+
+
+## Getting started
+
+*Sion* works with surface traps, defined through the *electrode* package. The simulation of ion dynamics is carried through the *pylion* environment.
+All functions, presented in *Sion* are described in example notebooks. Main file *sion.py* containes docs for each function.
+
+To publish the results, obtained with *Sion*, the following articles should be cited:
+1. [Surface trap with adjustable ion couplings for scalable and parallel gates](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.109.022605)
+
+
+## Features
+*   Simulation of ion motion in arbitrary polygon and point electrode surface trap.
+*   Optimization and simulation of arbitrary ion shuttling in polygon traps.
+*   Calculation of normal modes for general case of 1D, 2D, 3D mixed species ion crystals with arbitrary set of ions' secular frequencies.
+*   Calculation of anharmonic mathieu modes of ion crystals in surface traps.  
+*   Stability analysis of asymmetric planar traps.
+*   Optimization of DC voltage set of a planar trap to match the desired secular frequency and radial mode rotation angle in given positions.
+*   Convenient trap design. Layout may be imported from GDS file or created by defining the arbitrary electrode shape boundary. 
+
+## File structure
+
+*  'build/lib/sion.py': contains all the main functions.
+
+*  'examples': examples showing different features of *Sion*.
+
+*  'tests': verifications and tests of *Sion* work.
+
+Free software: MIT license

surface-ion-1.0.1/readme.md

@@ -0,0 +1,42 @@
+# *Sion* package
+
+Python package for simulation and analysis of ion crystals in surface electrode traps.
+
+## Installation
+
+To use *Sion*, the following packages are required to be installed from source and tested:
+- [pylion package](https://bitbucket.org/dtrypogeorgos/pylion/src/master/): LAMMPS wrapper for ion dynamics simulation. This package requires installation of LAMMPS software with the specific version. It will work well with the latest LAMMPS version, if in source file *pylion.py* at line 51 you change "lmp_serial" to "lmp".  
+- [electrode package](https://github.com/nist-ionstorage/electrode): Python package for convenient definition and analysis of surface electrode traps.  
+!Note: for correct execution of these packages, numpy<=1.21.0 is recquired. Alternatively one may install 
+
+The newest version may be installed via pip:  
+<code>pip install surface-ion</code>
+
+
+## Getting started
+
+*Sion* works with surface traps, defined through the *electrode* package. The simulation of ion dynamics is carried through the *pylion* environment.
+All functions, presented in *Sion* are described in example notebooks. Main file *sion.py* containes docs for each function.
+
+To publish the results, obtained with *Sion*, the following articles should be cited:
+1. [Surface trap with adjustable ion couplings for scalable and parallel gates](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.109.022605)
+
+
+## Features
+*   Simulation of ion motion in arbitrary polygon and point electrode surface trap.
+*   Optimization and simulation of arbitrary ion shuttling in polygon traps.
+*   Calculation of normal modes for general case of 1D, 2D, 3D mixed species ion crystals with arbitrary set of ions' secular frequencies.
+*   Calculation of anharmonic mathieu modes of ion crystals in surface traps.  
+*   Stability analysis of asymmetric planar traps.
+*   Optimization of DC voltage set of a planar trap to match the desired secular frequency and radial mode rotation angle in given positions.
+*   Convenient trap design. Layout may be imported from GDS file or created by defining the arbitrary electrode shape boundary. 
+
+## File structure
+
+*  'build/lib/sion.py': contains all the main functions.
+
+*  'examples': examples showing different features of *Sion*.
+
+*  'tests': verifications and tests of *Sion* work.
+
+Free software: MIT license

surface-ion-1.0.1/setup.cfg

@@ -0,0 +1,21 @@
+[bumpversion]
+current_version = 1.0.0
+commit = True
+tag = True
+
+[bumpversion:file:setup.py]
+search = version='{current_version}'
+replace = version='{new_version}'
+
+[bumpversion:file:sion/sion.py]
+search = __version__ = '{current_version}'
+replace = __version__ = '{new_version}'
+
+[tool:pytest]
+markers = 
+	slow: marks tests as slow (deselect with '-m "not slow"')
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

surface-ion-1.0.1/setup.py

@@ -0,0 +1,53 @@
+import sys
+from setuptools import setup, find_packages
+
+# install wexpect if windows
+if 'win32' in sys.platform:
+    expect = ['wexpect']
+else:
+    expect = ['pexpect>=4.2.1']
+
+
+with open('readme.md') as readme_file:
+    readme = readme_file.read()
+
+
+requirements = [
+    'numpy>=1.13.3',
+    'jinja2>=2.9.6',
+    'scipy>=1.12.1',
+    'scikit-optimize>=0.10.2',
+    'electrode>=1.4',
+    'matplotlib>=3.9.2',
+    'gdspy>=1.6.13',
+    'shapely>=2.0.6',
+    'tqdm>=4.66.6'
+] + expect
+
+
+short_description = (
+    "Python package for simulation and analysis of ion crystals in surface traps.")
+
+setup(
+    name='surface-ion',
+    version='1.0.1',
+    description=short_description,
+    long_description=readme,
+    author="Artem Podlesnyy",
+    author_email='a.podlesnyy@rqc.ru',
+    packages=find_packages(include=['surface-ion']),
+    package_data={'surface-ion': ['templates/*j2']},
+    include_package_data=True,
+    install_requires=requirements,
+    license="MIT license",
+    keywords=['surface trap', 'ion', 'quantum computing', 'ion simulation', 
+              'normal modes', 'mathieu modes', 'ion shuttling', 'voltage optimization'],
+    classifiers=[
+        'Development Status :: 2 - Pre-Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Natural Language :: English',
+        'Programming Language :: Python :: 3.6',
+    ],
+    test_suite='tests',
+)

surface-ion-1.0.1/surface_ion.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: surface-ion
+Version: 1.0.1
+Summary: Python package for simulation and analysis of ion crystals in surface traps.
+Author: Artem Podlesnyy
+Author-email: a.podlesnyy@rqc.ru
+License: MIT license
+Keywords: surface trap,ion,quantum computing,ion simulation,normal modes,mathieu modes,ion shuttling,voltage optimization
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.6
+License-File: LICENSE
+Requires-Dist: numpy>=1.13.3
+Requires-Dist: jinja2>=2.9.6
+Requires-Dist: scipy>=1.12.1
+Requires-Dist: scikit-optimize>=0.10.2
+Requires-Dist: electrode>=1.4
+Requires-Dist: matplotlib>=3.9.2
+Requires-Dist: gdspy>=1.6.13
+Requires-Dist: shapely>=2.0.6
+Requires-Dist: tqdm>=4.66.6
+Requires-Dist: wexpect
+
+# *Sion* package
+
+Python package for simulation and analysis of ion crystals in surface electrode traps.
+
+## Installation
+
+To use *Sion*, the following packages are required to be installed from source and tested:
+- [pylion package](https://bitbucket.org/dtrypogeorgos/pylion/src/master/): LAMMPS wrapper for ion dynamics simulation. This package requires installation of LAMMPS software with the specific version. It will work well with the latest LAMMPS version, if in source file *pylion.py* at line 51 you change "lmp_serial" to "lmp".  
+- [electrode package](https://github.com/nist-ionstorage/electrode): Python package for convenient definition and analysis of surface electrode traps.  
+!Note: for correct execution of these packages, numpy<=1.21.0 is recquired. Alternatively one may install 
+
+The newest version may be installed via pip:  
+<code>pip install surface-ion</code>
+
+
+## Getting started
+
+*Sion* works with surface traps, defined through the *electrode* package. The simulation of ion dynamics is carried through the *pylion* environment.
+All functions, presented in *Sion* are described in example notebooks. Main file *sion.py* containes docs for each function.
+
+To publish the results, obtained with *Sion*, the following articles should be cited:
+1. [Surface trap with adjustable ion couplings for scalable and parallel gates](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.109.022605)
+
+
+## Features
+*   Simulation of ion motion in arbitrary polygon and point electrode surface trap.
+*   Optimization and simulation of arbitrary ion shuttling in polygon traps.
+*   Calculation of normal modes for general case of 1D, 2D, 3D mixed species ion crystals with arbitrary set of ions' secular frequencies.
+*   Calculation of anharmonic mathieu modes of ion crystals in surface traps.  
+*   Stability analysis of asymmetric planar traps.
+*   Optimization of DC voltage set of a planar trap to match the desired secular frequency and radial mode rotation angle in given positions.
+*   Convenient trap design. Layout may be imported from GDS file or created by defining the arbitrary electrode shape boundary. 
+
+## File structure
+
+*  'build/lib/sion.py': contains all the main functions.
+
+*  'examples': examples showing different features of *Sion*.
+
+*  'tests': verifications and tests of *Sion* work.
+
+Free software: MIT license

surface-ion-1.0.1/surface_ion.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+readme.md
+setup.cfg
+setup.py
+surface_ion.egg-info/PKG-INFO
+surface_ion.egg-info/SOURCES.txt
+surface_ion.egg-info/dependency_links.txt
+surface_ion.egg-info/requires.txt
+surface_ion.egg-info/top_level.txt
+tests/FiveWireSimulation.py
+tests/RingSimulation.py
+tests/stability.ipynb

surface-ion-1.0.1/surface_ion.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

surface-ion-1.0.1/surface_ion.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy>=1.13.3
+jinja2>=2.9.6
+scipy>=1.12.1
+scikit-optimize>=0.10.2
+electrode>=1.4
+matplotlib>=3.9.2
+gdspy>=1.6.13
+shapely>=2.0.6
+tqdm>=4.66.6
+wexpect

surface-ion-1.0.1/surface_ion.egg-info/top_level.txt

@@ -0,0 +1 @@
+

surface-ion-1.0.1/tests/FiveWireSimulation.py

@@ -0,0 +1,157 @@
+"""
+Example, containing definition and simulation of the five-wire trap with
+three electrodes, containing 5 Ca ions. 
+Additionally, normal modes of the linear ion chain is calculated with
+axial_ and radial_normal_modes(), and verified with theoretical analysis.
+"""
+
+from __future__ import division
+import pylion as pl
+from pathlib import Path
+import matplotlib.pyplot as plt, numpy as np, scipy.constants as ct
+from electrode import (System, PolygonPixelElectrode, euler_matrix,
+                       PointPixelElectrode, PotentialObjective,
+                       PatternRangeConstraint, shaped)
+import sion as sn
+
+
+
+if __name__ == "__main__":
+    # Global definition of trap parameters.
+    L = 1e-6 # length scale
+    Vrf = 200. # RF peak voltage in V
+    mass = 40*ct.atomic_mass # ion mass
+    Z = 1*ct.elementary_charge # ion charge
+    Omega = 2*np.pi*30e6 # RF frequency in rad/s
+    Urf = Vrf * np.sqrt(Z / mass) / (2 * L * Omega)
+    scale = Z / ((L * Omega) ** 2 * mass)
+
+    # parameters of trap
+    DCtop = [[600, 760],[400, 760],[600, 760 ]] # Array of lengths and widths of Top electrodes
+    DCbottom = [[600, 760],[400, 760],[600, 760]]  # Array of lengths and widths of Bottom electrodes
+    c = [6000, 140]  # Width of central dc electrode
+    rftop = [6000, 100]  # width of top rf electrode, not including width of central electrode
+    rfbottom = [6000, 240]  # width of bottom rf electrode
+
+    sist, RF_electrodes, DC_electrodes = sn.five_wire_trap_design(Urf, DCtop ,DCbottom, rftop, rfbottom, c, need_coordinates = True, need_plot=True)
+
+    x0 = L*np.array(sist.minimum((0., 2, 3), axis=(0, 1, 2), coord=np.identity(3), method="Newton-CG"))
+    u_set = np.array([ 0, 0, 1.82122328, 7.77948793, -0.78451288, 7.77937332, 7.73905658, -7.90762408,  7.73944278])
+    dc_set = u_set[2:]
+
+    # routine to find secular frequencies in minimum point
+    with sist.with_voltages(dcs=u_set, rfs=None):
+        # Check if the minimum was shifted
+        x = sist.minimum((0., 90, 120), axis=(0, 1, 2), coord=np.identity(3), method="Newton-CG")
+        curv_z, mod_dir = sist.modes(x, sorted=False)
+        omega_sec = np.sqrt(Z * curv_z / mass) / (L * 2 * np.pi) * 1e-6
+    omega_sec *=1e6
+
+    ion_number = 5
+    x0 = x*1e-6
+
+    """Simulation"""
+
+    #insert your path to this file here
+    name = Path(__file__).stem
+
+    s = pl.Simulation(name)
+
+    #ions' declaration
+    ions = {'mass': 40, 'charge': 1}
+
+    #placing ion in random cloud near minimum
+    positions = sn.ioncloud_min(x0, ion_number, 10e-6)
+    s.append(pl.placeions(ions, positions))
+
+    #declaration of a five wire trap
+    s.append(sn.polygon_trap([Omega, Omega], [Vrf, Vrf], dc_set, RF_electrodes, DC_electrodes))
+
+    #cooling simulation
+    s.append(pl.langevinbath(0, 1e-7))
+
+    #files with simulation information
+    s.append(pl.dump('positions.txt', variables=['x', 'y', 'z'], steps=10))
+    s.append(pl.evolve(1e5))
+    try:
+        s.execute()
+        pass
+    except:
+        pass
+
+    _, data = pl.readdump('positions.txt')
+    data *= 1e6
+
+    final_x = data[-1, :, 0]
+    final_y = data[-1, :, 1]
+    final_z = data[-1, :, 2]
+
+    ion_positions = np.zeros([ion_number, 3])
+    sort = np.argsort(final_x)
+        
+    equilibrium_positions = []
+    for i in range(ion_number):
+        equilibrium_positions.append(L*np.array([np.mean(data[9000:, i, 0]), np.mean(data[9000:, i, 1]), np.mean(data[9000:, i, 2])]))
+    equilibrium_positions = np.array(equilibrium_positions)
+
+    k=0
+    for i in sort:
+        ion_positions[k] = np.array([equilibrium_positions[i][0], equilibrium_positions[i][1], equilibrium_positions[i][2]])
+        k+=1
+
+    np.set_printoptions(2)
+    print('Final positions of ions in um:\n', ion_positions)
+
+    """Normal modes"""
+
+    freqs, modes = sn.normal_modes(ion_positions, omega_sec, mass, linear = True)
+    axial_freqs = freqs[0]
+    axial_modes = modes[0]
+    np.set_printoptions(0)
+
+    print('Axial mode frequencies:', axial_freqs, 'Hz')
+
+    np.set_printoptions(4)
+    print('Axial modes:', axial_modes)
+
+    theor_modes = -1*np.array([[0.4472,0.4472,0.4472,0.4472,0.4472],[0.6395,0.3017, 0, -0.3017, -0.6395],
+                [0.5377, -0.2805, -0.5143,-0.2805, 0.5377], [-0.3017,0.6395,0,-0.6395,0.3017],
+                [0.1045,-0.4704,0.7318,-0.4704, 0.1045]])
+    theor_freqs = np.array([1,3,5.818,9.332,13.47])
+    freqs = np.sqrt(theor_freqs)*omega_sec[0]
+    print('Verification process.')
+
+    l2 = (ct.e**2 / (4 * np.pi * ct.epsilon_0 * 40 * ct.atomic_mass * (omega_sec[0] * 2 * np.pi) ** 2)) ** (1/3)
+    theor_positions = np.array([-1.7429, -0.8221, 0, 0.8221, 1.7429]) * l2
+    pos_diff = np.linalg.norm(theor_positions - final_x[sort]*1e-6)
+
+    print('Difference from theoretical positions:', np.round(pos_diff * 1e6, 4), 'um')
+
+    print('Difference from theoretical frequencies:', np.round(np.abs(freqs-axial_freqs),1), 'Hz')
+
+    diff = np.zeros(5)
+    for i in range(5):
+        dif = axial_modes - theor_modes
+        diff[i] = np.linalg.norm(dif[i])
+        if diff[i] > 1:
+            dif = axial_modes + theor_modes
+            diff[i] = np.linalg.norm(dif[i])
+    print('Difference in mode vectors', diff)
+
+    # Plot of ion crystal evolution
+    plt.figure()
+    for n in range(ion_number):
+        plt.plot(np.arange(data.shape[0]) * 10 + 1, data[:, n, 0])
+    plt.title('Evolution of ion\'s x coordinates')
+    plt.xlabel('Time step')
+    plt.ylabel('Ion\'s x coordinates')
+    plt.show()
+
+    # Plot of the final ion crystal configuration
+    plt.figure()
+    plt.scatter(data[-1, :, 0], data[-1, :, 1])
+    plt.title('Ion\'s equilibrium positions')
+    plt.xlabel('Ion\'s x coordinates')
+    plt.ylabel('Ion\'s y coordinates')
+    plt.ylim([80, 120])
+    plt.show()

surface-ion-1.0.1/tests/RingSimulation.py

@@ -0,0 +1,92 @@
+"""
+In this example we model single ion in the RF ring electrode.
+The parameters are chosen, so theoretically the position of minimum (and single ion)
+will be at the point (0,0, 100) mkm. 
+The increase in accuracy, followed with the increse in the resolution, leads to 
+the increase time, required for the simulation.
+"""
+
+
+from __future__ import division
+import pylion as pl
+from pathlib import Path
+import matplotlib as mpl
+import matplotlib.pyplot as plt, numpy as np, scipy.constants as ct
+from mpl_toolkits.mplot3d import Axes3D
+from electrode import (System, PolygonPixelElectrode, PointPixelElectrode)
+
+import sion as sn
+
+
+if __name__ == "__main__":
+    #trap parameters
+    Vrf = 120.  # RF peak voltage in V
+    mass = 40 * ct.atomic_mass  # ion mass
+    Z = 1 * ct.elementary_charge  # ion charge
+    Omega = 2 * np.pi * 30e6  # RF frequency in rad/s
+    Urf = Vrf*np.sqrt(Z/mass)/(2*Omega)
+    
+    #theoretically obtained radiuses of the ring for ion's height to be 100 mkm
+    sc = np.sqrt(3/(4*np.sin(np.pi/12)**2)-1)
+    r = 100/np.sqrt(2)*1e-6
+    R = 100*sc*1e-6
+    res = 50
+    dif = 0
+    Nring = 1
+    scale = 1.5*R
+    
+    def boundaries(i, x):
+        if i == 0:
+            if (x[0]**2+x[1]**2 > r**2) and (x[0]**2+x[1]**2 < R**2):
+                return True
+            else:
+                return False
+    
+    s, trap = sn.point_trap_design(frequencies = [Omega], rf_voltages = [Vrf], dc_voltages = [], boundaries = boundaries, scale = scale, resolution = res, need_plot = True, need_coordinates = True)
+    
+    
+    #placing 1 ion
+    ion_number = 1
+    distance = 0
+    positions = sn.ions_in_order([0,0,95e-6], ion_number, distance)
+    
+    #insert your path to this file here
+    name = Path('RingSimulation.py').stem
+    
+    sim = pl.Simulation(name)
+    
+    #ion's declaration
+    ions = {'mass': 40, 'charge': 1}
+    
+    sim.append(pl.placeions(ions, positions))
+    
+    #ring trap initialization
+    sim.append(sn.point_trap(trap))
+    
+    #cooling simulation
+    sim.append(pl.langevinbath(0, 1e-7))
+    
+    #files with information
+    sim.append(pl.dump('posring.txt', variables=['x', 'y', 'z'], steps=10))
+    sim.append(pl.evolve(1e4))
+    #sim.execute()
+    
+    
+    _, data = pl.readdump('posring.txt')
+    data *= 1e6
+    
+    final_x = data[-1, :, 0]
+    final_y = data[-1, :, 1]
+    final_z = data[-1, :, 2]
+    
+    print('Initial ion position:\n', [0, 0, 95])
+    print('Final ion position:\n', np.round([final_x[0], final_y[0], final_z[0]]), 'um')
+    print('Distance from theoretical position:', np.round(np.linalg.norm(np.array([final_x[0], final_y[0], final_z[0]]) - np.array([0, 0, 100])), 3), 'um')
+    
+    plt.figure()
+    for n in range(ion_number):
+        plt.plot(np.arange(data.shape[0]) * 10 + 1, data[:, n, 2])
+    plt.title('Evolution of ion\'s z coordinates')
+    plt.xlabel('Time step')
+    plt.ylabel('z, um')
+    plt.show()