kenv - pypi Package Compare versions

Comparing version 0.2.3.3 to 0.3.0.0

kenv.egg-info/PKG-INFO

 Metadata-Version: 2.1
 Name: kenv
-Version: 0.2.3.3
-Summary: Kapchinscky ENVelope (KENV) -
- solver of the Kapchinsky-Vladimirsky envelope equation
+Version: 0.3.0.0
+Summary: Kapchinscky ENVelope (KENV) -  solver of the Kapchinsky-Vladimirsky envelope equation
 Home-page: https://github.com/fuodorov/kenv
@@ -7,0 +6,0 @@ Author: Vyacheslav Fedorov

kenv/__init__.py

@@ -1,3 +0,1 @@
-#__init__
-
 from .constants import *
@@ -8,6 +6,6 @@ from .beam import *
 
-__version__ = '0.2.3.3'
+__version__ = '0.3.0.0'
 __doc__ = """Kapchinscky ENVelope (KENV) -
  solver of the Kapchinsky-Vladimirsky envelope equation"""
-
-__all__ = constants.__all__ + beam.__all__ + accelerator.__all__ + solver.__all__
+__all__ = (constants.__all__ + beam.__all__ +
+           accelerator.__all__ + solver.__all__)

kenv/accelerator.py

@@ -1,13 +0,5 @@
-# accelerator.py
-"""Create an accelerator.
-
-"""
-
 import numpy as np
-from scipy import interpolate, integrate, misc
+from scipy import interpolate, integrate
 
-__all__ = ['Element',
-           'Accelerator',
-           'read_fields',
-           'read_offsets']
+__all__ = ['Element', 'Accelerator', 'read_fields', 'read_offsets']
 
@@ -36,6 +28,6 @@
                  *,
-                 x: float=0.0,
-                 xp: float=0.0,
-                 y: float=0.0,
-                 yp: float=0.0):
+                 x: float = 0.0,
+                 xp: float = 0.0,
+                 y: float = 0.0,
+                 yp: float = 0.0):
         self.z0 = z0
@@ -55,2 +47,3 @@ self.max_field = max_field
 
+
 def read_fields(beamline: dict,
@@ -70,3 +63,3 @@ z: np.arange) -> interpolate.interp1d:
     if not beamline:
-        z_data = [i/len(z) for i in range(len(z))]
+        z_data = [i / len(z) for i in range(len(z))]
         F_data = [0 for i in range(len(z))]
@@ -85,14 +78,20 @@ f = interpolate.interp1d(
             M = field_files[element.file_name]
-            z_data = M[:,0] + element.z0
-            F_data = M[:,1]
-            dz = (z_data[-1] - z_data[0])/len(z_data)
+            z_data = M[:, 0] + element.z0
+            F_data = M[:, 1]
+            dz = (z_data[-1] - z_data[0]) / len(z_data)
 
             f = interpolate.interp1d(
-                z_data, element.max_field*F_data, kind='cubic',
-                fill_value=(0, 0), bounds_error=False
+                z_data,
+                element.max_field * F_data,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
             )
 
             f_prime = interpolate.interp1d(
-                z_data, element.max_field*np.gradient(F_data, dz), kind='cubic',
-                fill_value=(0, 0), bounds_error=False
+                z_data,
+                element.max_field * np.gradient(F_data, dz),
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
             )
@@ -104,4 +103,6 @@
             if not element.max_field == 0:
-                element.length = ((integrate.cumtrapz(f(z_data), z_data)[-1])**2)/((integrate.cumtrapz(f(z_data)**2, z_data))[-1])
-                element.field = (integrate.cumtrapz(f(z_data)**2, z_data)[-1])/(integrate.cumtrapz(f(z_data), z_data)[-1])
+                int_f = integrate.cumtrapz(f(z_data), z_data)[-1]
+                int_ff = integrate.cumtrapz(f(z_data)**2, z_data)[-1]
+                element.length = int_f**2 / int_ff
+                element.field = int_ff / int_f
                 element.z_start = element.z0 - element.length
@@ -115,11 +116,16 @@ element.z_stop = element.z0 + element.length
 
-    F = interpolate.interp1d(z, F, kind='cubic', fill_value=(0, 0), bounds_error=False)
+    F = interpolate.interp1d(z, F, kind='cubic',
+                             fill_value=(0, 0), bounds_error=False)
     F_int = integrate.cumtrapz(F(z), z)
-    F_prime = interpolate.interp1d(z, F_prime, kind='cubic', fill_value=(0, 0), bounds_error=False)
-    F_int = interpolate.interp1d(z[1:], F_int, kind='cubic', fill_value=(F_int[0], F_int[-1]), bounds_error=False)
+    F_prime = interpolate.interp1d(z, F_prime, kind='cubic',
+                                   fill_value=(0, 0), bounds_error=False)
+    F_int = interpolate.interp1d(z[1:], F_int, kind='cubic',
+                                 fill_value=(F_int[0], F_int[-1]),
+                                 bounds_error=False)
 
     return F, F_prime, F_int
 
+
 def read_offsets(beamline: dict,
-                z: np.arange) -> interpolate.interp1d:
+                 z: np.arange) -> interpolate.interp1d:
     """Sews elements into a function of z.
@@ -135,6 +141,7 @@
     F = 0
-    offset_correct_x, offset_correct_y, offset_correct_xp, offset_correct_yp  = 0, 0, 0, 0
+    offset_correct_x, offset_correct_y = 0, 0
+    offset_correct_xp, offset_correct_yp = 0, 0
 
     if not beamline:
-        z_data = [i/len(z) for i in range(len(z))]
+        z_data = [i / len(z) for i in range(len(z))]
         F_data = [0 for i in range(len(z))]
@@ -146,3 +153,4 @@ f = interpolate.interp1d(
         F = F + f(z)
-        offset_correct_x, offset_correct_y, offset_correct_xp, offset_correct_yp = F, F, F, F
+        offset_correct_x, offset_correct_y = F, F
+        offset_correct_xp, offset_correct_yp = F, F
     else:
@@ -153,28 +161,42 @@ for element in beamline.values():
             M = field_files[element.file_name]
-            z_data = M[:,0] + element.z0
-            F_data = M[:,1]
+            z_data = M[:, 0] + element.z0
+            F_data = M[:, 1]
 
             if not element.length == 0:
-                z_data = np.linspace(element.z_start, element.z_stop, len(z_data))
-
+                z_data = np.linspace(element.z_start, element.z_stop,
+                                     len(z_data))
+                x, xp = element.x, element.xp
+                y, yp = element.y, element.yp
+                z0 = element.z0
                 f_x = interpolate.interp1d(
-                    z_data, [element.x + (z_data[i]-element.z0)*element.xp for i in range(len(z_data))],
-                    fill_value=(0,0), bounds_error=False
+                    z_data,
+                    [x + (z_data[i] - z0) * xp for i in range(len(z_data))],
+                    fill_value=(0, 0),
+                    bounds_error=False
                 )
                 f_xp = interpolate.interp1d(
-                    z_data, [element.xp for i in range(len(z_data))],
-                    fill_value=(0, 0), bounds_error=False
+                    z_data,
+                    [xp for i in range(len(z_data))],
+                    fill_value=(0, 0),
+                    bounds_error=False
                 )
                 f_y = interpolate.interp1d(
-                    z_data, [element.y + (z_data[i]-element.z0)*element.yp for i in range(len(z_data))],
-                    fill_value=(0, 0), bounds_error=False
+                    z_data,
+                    [y + (z_data[i] - z0) * yp for i in range(len(z_data))],
+                    fill_value=(0, 0),
+                    bounds_error=False
                 )
                 f_yp = interpolate.interp1d(
-                    z_data, [element.yp for i in range(len(z_data))],
-                    fill_value=(0, 0), bounds_error=False
+                    z_data,
+                    [yp for i in range(len(z_data))],
+                    fill_value=(0, 0),
+                    bounds_error=False
                 )
             else:
                 f = interpolate.interp1d(
-                    z_data, 0*F_data, kind='cubic',
-                    fill_value=(0, 0), bounds_error=False
+                    z_data,
+                    0 * F_data,
+                    kind='cubic',
+                    fill_value=(0, 0),
+                    bounds_error=False
                 )
@@ -188,8 +210,33 @@ f_x, f_xp, f_y, f_yp = f, f, f, f
 
-    offset_correct_x = interpolate.interp1d(z, offset_correct_x, kind='linear', fill_value=(0, 0), bounds_error=False)
-    offset_correct_y = interpolate.interp1d(z, offset_correct_y, kind='linear', fill_value=(0, 0), bounds_error=False)
-    offset_correct_xp = interpolate.interp1d(z, offset_correct_xp, kind='linear', fill_value=(0, 0), bounds_error=False)
-    offset_correct_yp = interpolate.interp1d(z, offset_correct_yp, kind='linear', fill_value=(0, 0), bounds_error=False)
+    offset_correct_x = interpolate.interp1d(
+        z,
+        offset_correct_x,
+        kind='linear',
+        fill_value=(0, 0),
+        bounds_error=False
+    )
+    offset_correct_y = interpolate.interp1d(
+        z,
+        offset_correct_y,
+        kind='linear',
+        fill_value=(0, 0),
+        bounds_error=False
+    )
+    offset_correct_xp = interpolate.interp1d(
+        z,
+        offset_correct_xp,
+        kind='linear',
+        fill_value=(0, 0),
+        bounds_error=False
+    )
+    offset_correct_yp = interpolate.interp1d(
+        z,
+        offset_correct_yp,
+        kind='linear',
+        fill_value=(0, 0),
+        bounds_error=False
+    )
+    return (offset_correct_x, offset_correct_xp,
+            offset_correct_y, offset_correct_yp)
 
-    return offset_correct_x, offset_correct_xp, offset_correct_y, offset_correct_yp
 
@@ -228,16 +275,19 @@ class Accelerator:
         self.z = self.parameter = np.arange(z_start, z_stop, dz)
-
         self.Bx_beamline, self.By_beamline, self.Bz_beamline = {}, {}, {}
         self.Ez_beamline = {}
         self.Gz_beamline = {}
-        self.Bx, self.By, self.Bz = interpolate.interp1d, interpolate.interp1d, interpolate.interp1d
+        self.Bx, self.By = interpolate.interp1d, interpolate.interp1d
+        self.Bz = interpolate.interp1d
         self.Ez = interpolate.interp1d
         self.Gz = interpolate.interp1d
-        self.dBxdz, self.dBydz, self.dBzdz = interpolate.interp1d, interpolate.interp1d, interpolate.interp1d
+        self.dBxdz, self.dBydz = interpolate.interp1d, interpolate.interp1d
+        self.dBzdz = interpolate.interp1d
         self.dEzdz = interpolate.interp1d
         self.dGzdz = interpolate.interp1d
-        self.Bxdz, self.Bydz, self.Bzdz = interpolate.interp1d, interpolate.interp1d, interpolate.interp1d
+        self.Bxdz, self.Bydz = interpolate.interp1d, interpolate.interp1d
+        self.Bzdz = interpolate.interp1d
         self.Ezdz = interpolate.interp1d
         self.Gzdz = interpolate.interp1d
-        self.Dx, self.Dxp, self.Dy, self.Dyp = interpolate.interp1d, interpolate.interp1d, interpolate.interp1d, interpolate.interp1d
+        self.Dx, self.Dxp = interpolate.interp1d, interpolate.interp1d
+        self.Dy, self.Dyp = interpolate.interp1d, interpolate.interp1d
 
@@ -250,6 +300,6 @@ def add_solenoid(self,
                      *,
-                     x: float=0.0,
-                     xp: float=0.0,
-                     y: float=0.0,
-                     yp: float=0.0) -> None:
+                     x: float = 0.0,
+                     xp: float = 0.0,
+                     y: float = 0.0,
+                     yp: float = 0.0) -> None:
         """Creates a solenoid in the accelerator.
@@ -274,6 +324,6 @@
                   *,
-                  x: float=0.0,
-                  xp: float=0.0,
-                  y: float=0.0,
-                  yp: float=0.0) -> None:
+                  x: float = 0.0,
+                  xp: float = 0.0,
+                  y: float = 0.0,
+                  yp: float = 0.0) -> None:
         """Creates an accelerating module in the accelerator.
@@ -341,3 +391,3 @@
     def delete_solenoid(self,
-                        name: str='all') -> None:
+                        name: str = 'all') -> None:
         """Delete a solenoid in the accelerator.
@@ -357,3 +407,3 @@
     def delete_accel(self,
-                     name: str='all') -> None:
+                     name: str = 'all') -> None:
         """Delete a accelerating module in the accelerator.
@@ -373,3 +423,3 @@
     def delete_quadrupole(self,
-                          name: str='all') -> None:
+                          name: str = 'all') -> None:
         """Delete a quadrupole in the accelerator.
@@ -389,3 +439,3 @@
     def delete_corrector_x(self,
-                           name: str='all') -> None:
+                           name: str = 'all') -> None:
         """Delete a corrector in the accelerator.
@@ -405,3 +455,3 @@
     def delete_corrector_y(self,
-                           name: str='all') -> None:
+                           name: str = 'all') -> None:
         """Delete a corrector in the accelerator.
@@ -423,16 +473,46 @@
 
-        self.Bx, self.dBxdz, self.Bxdz = read_fields(self.Bx_beamline, self.parameter)
-        self.By, self.dBydz, self.Bydz = read_fields(self.By_beamline, self.parameter)
-        self.Bz, self.dBzdz, self.Bzdz = read_fields(self.Bz_beamline, self.parameter)
-        self.Ez, self.dEzdz, self.Ezdz = read_fields(self.Ez_beamline, self.parameter)
-        self.Gz, self.dGzdz, self.Gzdz = read_fields(self.Gz_beamline, self.parameter)
+        self.Bx, self.dBxdz, self.Bxdz = read_fields(self.Bx_beamline,
+                                                     self.parameter)
+        self.By, self.dBydz, self.Bydz = read_fields(self.By_beamline,
+                                                     self.parameter)
+        self.Bz, self.dBzdz, self.Bzdz = read_fields(self.Bz_beamline,
+                                                     self.parameter)
+        self.Ez, self.dEzdz, self.Ezdz = read_fields(self.Ez_beamline,
+                                                     self.parameter)
+        self.Gz, self.dGzdz, self.Gzdz = read_fields(self.Gz_beamline,
+                                                     self.parameter)
+        Dx_Bz, Dxp_Bz, Dy_Bz, Dyp_Bz = read_offsets(self.Bz_beamline,
+                                                    self.parameter)
+        Dx_Ez, Dxp_Ez, Dy_Ez, Dyp_Ez = read_offsets(self.Ez_beamline,
+                                                    self.parameter)
 
-        Dx_Bz, Dxp_Bz, Dy_Bz, Dyp_Bz = read_offsets(self.Bz_beamline, self.parameter)
-        Dx_Ez, Dxp_Ez, Dy_Ez, Dyp_Ez = read_offsets(self.Ez_beamline, self.parameter)
+        self.Dx = interpolate.interp1d(
+            self.z,
+            Dx_Bz(self.z) + Dx_Ez(self.z),
+            kind='linear',
+            fill_value=(0, 0),
+            bounds_error=False
+        )
+        self.Dxp = interpolate.interp1d(
+            self.z,
+            Dxp_Bz(self.z) + Dxp_Ez(self.z),
+            kind='linear',
+            fill_value=(0, 0),
+            bounds_error=False
+        )
+        self.Dy = interpolate.interp1d(
+            self.z,
+            Dy_Bz(self.z) + Dy_Ez(self.z),
+            kind='linear',
+            fill_value=(0, 0),
+            bounds_error=False
+        )
+        self.Dyp = interpolate.interp1d(
+            self.z,
+            Dyp_Bz(self.z) + Dyp_Ez(self.z),
+            kind='linear',
+            fill_value=(0, 0),
+            bounds_error=False
+        )
 
-        self.Dx = interpolate.interp1d(self.z, Dx_Bz(self.z) + Dx_Ez(self.z), kind='linear', fill_value=(0, 0), bounds_error=False)
-        self.Dxp = interpolate.interp1d(self.z, Dxp_Bz(self.z) + Dxp_Ez(self.z), kind='linear', fill_value=(0, 0), bounds_error=False)
-        self.Dy = interpolate.interp1d(self.z, Dy_Bz(self.z) + Dy_Ez(self.z), kind='linear', fill_value=(0, 0), bounds_error=False)
-        self.Dyp = interpolate.interp1d(self.z, Dyp_Bz(self.z) + Dyp_Ez(self.z), kind='linear', fill_value=(0, 0), bounds_error=False)
-
     def __str__(self):
@@ -442,22 +522,24 @@ string = 'Accelerator structure.\n'
         for element in self.Bz_beamline.values():
-            string +="\t[ %.5f m, %.5f T, '%s', '%s', %.5f m, %.5f rad, %.5f m, %.5f rad],\n"\
-             % (element.z0, element.max_field, element.file_name, element.name,
-                element.x, element.xp, element.y, element.yp)
+            string += (f"\t[ {element.z0} m, {element.max_field} T, "
+                       f"{element.file_name}, {element.name}, "
+                       f"{element.x} m, {element.xp} rad, "
+                       f"{element.y} m, {element.yp} rad] \n")
         string += '\tAccelerating modules:\n'
         for element in self.Ez_beamline.values():
-            string +="\t[ %.5f m, %.5f T, '%s', '%s', %.5f m, %.5f rad, %.5f m, %.5f rad],\n"\
-             % (element.z0, element.max_field, element.file_name, element.name,
-                element.x, element.xp, element.y, element.yp)
+            string += (f"\t[ {element.z0} m, {element.max_field} T, "
+                       f"{element.file_name}, {element.name}, "
+                       f"{element.x} m, {element.xp} rad, "
+                       f"{element.y} m, {element.yp} rad] \n")
         string += '\tQuadrupoles:\n'
         for element in self.Gz_beamline.values():
-            string +="\t[ %.5f m, %.5f T, '%s', '%s'],\n"\
-             % (element.z0, element.max_field, element.file_name, element.name)
+            string += (f"\t[ {element.z0} m, {element.max_field} T, "
+                       f"{element.file_name}, {element.name} \n")
         string += '\tCorrectors x:\n'
         for element in self.By_beamline.values():
-            string +="\t[ %.5f m, %.5f T, '%s', '%s'],\n"\
-             % (element.z0, element.max_field, element.file_name, element.name)
+            string += (f"\t[ {element.z0} m, {element.max_field} T, "
+                       f"{element.file_name}, {element.name} \n")
         string += '\tCorrectors y:\n'
         for element in self.Bx_beamline.values():
-            string +="\t[ %.5f m, %.5f T, '%s', '%s'],\n"\
-             % (element.z0, element.max_field, element.file_name, element.name)
+            string += (f"\t[ {element.z0} m, {element.max_field} T, "
+                       f"{element.file_name}, {element.name} \n")
         return string
@@ -464,0 +546,0 @@

kenv/beam.py

@@ -1,18 +0,17 @@
-# beam.py
-"""Creating an electron beam."""
-
+import kenv.constants as consts
 import numpy as np
-from .constants import *
 
 __all__ = ['Beam', 'Particle']
 
+
 class Particle:
     """Creating an particle"""
+
     def __init__(self, *,
-                 x: float=.0e0,
-                 y: float=.0e0,
-                 xp: float=.0e0,
-                 yp: float=.0e0,
-                 energy: float=.0e0,
-                 larmor_angle: float=.0e0):
+                 x: float = .0e0,
+                 y: float = .0e0,
+                 xp: float = .0e0,
+                 yp: float = .0e0,
+                 energy: float = .0e0,
+                 larmor_angle: float = .0e0):
         self.x = x
@@ -23,15 +22,16 @@ self.y = y
         self.energy = energy
-        self.gamma = gamma = self.energy / mass_rest_electron + 1
-        self.beta = beta = np.sqrt(1 - 1 / (gamma*gamma))
-        self.p = self.momentum = gamma*beta*mass_rest_electron
+        self.gamma = gamma = self.energy / consts.mass_rest_electron + 1
+        self.beta = beta = np.sqrt(1 - 1 / (gamma * gamma))
+        self.p = self.momentum = gamma * beta * consts.mass_rest_electron
         self.larmor_angle = larmor_angle
 
     def __str__(self):
-            return 'Particle parameters:' + '\n' \
-                    +'\tHorizontal position\t%0.1f mm'%(self.x*1e3) + '\n' \
-                    +'\tVertical position\t%0.1f mm'%(self.y*1e3) + '\n' \
-                    +'\tHorizontal angle\t%0.1f mrad'%(self.xp*1e3) + '\n' \
-                    +'\tVertical angle\t%0.1f mrad'%(self.yp*1e3)+ '\n' \
-                    +'\tEnergy\t%0.3f MeV'%(self.energy) + '\n'
+        return 'Particle parameters:' + '\n' \
+            + '\tHorizontal position\t%0.1f mm' % (self.x * 1e3) + '\n' \
+            + '\tVertical position\t%0.1f mm' % (self.y * 1e3) + '\n' \
+            + '\tHorizontal angle\t%0.1f mrad' % (self.xp * 1e3) + '\n' \
+            + '\tVertical angle\t%0.1f mrad' % (self.yp * 1e3) + '\n' \
+            + '\tEnergy\t%0.3f MeV' % (self.energy) + '\n'
 
+
 class Beam:
@@ -61,19 +61,19 @@ """Creating an electron beam.
     def __init__(self, *,
-                 current: float=.0e0,
-                 energy: float=.0e0,
-                 radius: float=.0e0,
-                 radius_x: float=.0e0,
-                 radius_y: float=.0e0,
-                 rp: float=.0e0,
-                 radius_xp: float=.0e0,
-                 radius_yp: float=.0e0,
-                 normalized_emittance: float=.0e0,
-                 normalized_emittance_x: float=.0e0,
-                 normalized_emittance_y: float=.0e0,
-                 x: float=.0e0,
-                 y: float=.0e0,
-                 xp: float=.0e0,
-                 yp: float=.0e0,
-                 larmor_angle: float=.0e0,
-                 charge: int=-1):
+                 current: float = .0e0,
+                 energy: float = .0e0,
+                 radius: float = .0e0,
+                 radius_x: float = .0e0,
+                 radius_y: float = .0e0,
+                 rp: float = .0e0,
+                 radius_xp: float = .0e0,
+                 radius_yp: float = .0e0,
+                 normalized_emittance: float = .0e0,
+                 normalized_emittance_x: float = .0e0,
+                 normalized_emittance_y: float = .0e0,
+                 x: float = .0e0,
+                 y: float = .0e0,
+                 xp: float = .0e0,
+                 yp: float = .0e0,
+                 larmor_angle: float = .0e0,
+                 charge: int = -1):
 
@@ -94,6 +94,6 @@ self.current = current
             self.radius_y = radius
-        if rp !=.0e0:
+        if rp != .0e0:
             self.radius_xp = rp
             self.radius_yp = rp
-        if normalized_emittance !=.0e0:
+        if normalized_emittance != .0e0:
             self.normalized_emittance_x = normalized_emittance
@@ -110,8 +110,8 @@ self.normalized_emittance_y = normalized_emittance
 
-        self.gamma = gamma = self.energy / mass_rest_electron + 1
-        self.beta = beta = np.sqrt(1 - 1 / (gamma*gamma))
+        self.gamma = gamma = self.energy / consts.mass_rest_electron + 1
+        self.beta = beta = np.sqrt(1 - 1 / (gamma * gamma))
 
-        self.p = self.momentum = gamma*beta*mass_rest_electron
-        self.px = self.p*self.radius_xp
-        self.py = self.p*self.radius_yp
+        self.p = self.momentum = gamma * beta * consts.mass_rest_electron
+        self.px = self.p * self.radius_xp
+        self.py = self.p * self.radius_yp
         self.pz = self.p
@@ -121,20 +121,17 @@ self.description = ''
     def __str__(self):
-        self.description = 'Beam parameters:' + '\n' \
-                +'\tCurrent\t%0.0f A'%(self.current) + '\n' \
-                +'\tEnergy\t%0.3f MeV'%(self.energy) + '\n' \
-                +'\tTotal momentum\t%0.3f MeV/c'%(self.momentum) + '\n' \
-                +'\tRel. factor\t%0.3f'%(self.gamma) + '\n' \
-                +'\tRadius x\t%0.1f mm'%(self.radius_x*1e3) + '\n' \
-                +'\tRadius y\t%0.1f mm'%(self.radius_y*1e3) + '\n' \
-                +'\tRadius x prime\t%0.1f mrad'%(self.radius_xp*1e3) + '\n' \
-                +'\tRadius y prime\t%0.1f mrad'%(self.radius_yp*1e3) + '\n' \
-                +'\tHorizontal centroid position\t%0.1f mm'%(self.x*1e3) + '\n' \
-                +'\tVertical centroid position\t%0.1f mm'%(self.y*1e3) + '\n' \
-                +'\tHorizontal centroid angle\t%0.1f mrad'%(self.xp*1e3) + '\n' \
-                +'\tVertical centroid angle\t%0.1f mrad'%(self.yp*1e3) + '\n' \
-                +'\tLarmor angle\t%0.1f rad'%(self.larmor_angle) + '\n' \
-                +'\tNormalized emittance x\t%0.1f mm*mrad'%\
-                (self.normalized_emittance_x*1e6) + '\n' \
-                +'\tNormalized emittance y\t%0.1f mm*mrad'%\
-                (self.normalized_emittance_y*1e6) + '\n'
+        self.description = 'Beam parameters:\n' \
+            + f'\tCurrent\t{self.current} A\n' \
+            + f'\tEnergy\t{self.energy} MeV\n' \
+            + f'\tTotal momentum\t{self.momentum} MeV/c\n' \
+            + f'\tRel. factor\t{self.gamma}\n' \
+            + f'\tRadius x\t{self.radius_x * 1e3} mm\n' \
+            + f'\tRadius y\t{self.radius_y * 1e3} mm\n' \
+            + f'\tRadius x prime\t{self.radius_xp * 1e3} mrad\n' \
+            + f'\tRadius y prime\t{self.radius_yp * 1e3} mrad\n' \
+            + f'\tHorizontal centroid position\t{self.x * 1e3} mm\n' \
+            + f'\tVertical centroid position\t{self.y * 1e3} mm\n' \
+            + f'\tHorizontal centroid angle\t{self.xp * 1e3} mrad\n' \
+            + f'\tVertical centroid angle\t{self.yp * 1e3} mrad\n' \
+            + f'\tLarmor angle\t{self.larmor_angle} rad\n' \
+            + f'\tNorm. emitt x\t{self.normalized_emittance_x*1e6} mm*mrad\n'
         return self.description

kenv/constants.py

@@ -1,4 +0,1 @@
-# constants.py
-"""Constants."""
-
 __all__ = ['mc2',
@@ -5,0 +2,0 @@ 'speed_light',

kenv/solver.py

@@ -1,9 +0,6 @@
-# solver.py
-"""Simulation of the envelope beam in the accelerator."""
-
+import kenv.constants as consts
 import numpy as np
-from scipy import interpolate, integrate, misc
+from kenv.beam import Particle
+from scipy import interpolate, misc
 from scipy.integrate import solve_ivp
-from .constants import *
-from .beam import *
 
@@ -14,2 +11,3 @@ __all__ = ['Sim',
 
+
 class Equations:
@@ -25,4 +23,4 @@ """Located derivative for further integration."""
     def envelope_prime(self,
-                       z:np.arange,
-                       X:list) -> list:
+                       z: np.arange,
+                       X: list) -> list:
         """Located derivative for further integration
@@ -38,24 +36,26 @@ Kapchinscky equation for envelope beam.
 
-        g = self.beam.gamma + self.beam.charge*self.accelerator.Ezdz(z)/mass_rest_electron
-        dgdz = self.beam.charge*self.accelerator.Ez(z)/mass_rest_electron
-        d2gdz2 = self.beam.charge*self.accelerator.dEzdz(z)/mass_rest_electron
-        beta = np.sqrt(1 - 1 / (g*g))
-        p = g*beta*mass_rest_electron
-
-        K_s = (self.beam.charge*speed_light*self.accelerator.Bz(z) / (2*p*MeV))**2
-        K_q = (self.beam.charge*speed_light*self.accelerator.Gz(z) / (p*MeV))
+        g = self.beam.gamma + self.beam.charge * \
+            self.accelerator.Ezdz(z) / consts.mass_rest_electron
+        dgdz = self.beam.charge * \
+            self.accelerator.Ez(z) / consts.mass_rest_electron
+        d2gdz2 = self.beam.charge * \
+            self.accelerator.dEzdz(z) / consts.mass_rest_electron
+        beta = np.sqrt(1 - 1 / (g * g))
+        p = g * beta * consts.mass_rest_electron
+        K_s = (self.beam.charge * consts.speed_light *
+               self.accelerator.Bz(z) / (2 * p * consts.MeV))**2
+        K_q = (self.beam.charge * consts.speed_light *
+               self.accelerator.Gz(z) / (p * consts.MeV))
         K_x = K_s - K_q
         K_y = K_s + K_q
+        emitt_x = self.beam.normalized_emittance_x / (g * beta)
+        emitt_y = self.beam.normalized_emittance_y / (g * beta)
+        P = 2 * self.beam.current / (consts.alfven_current * (g * beta)**3)
 
-        emitt_x = self.beam.normalized_emittance_x / (g*beta)
-        emitt_y = self.beam.normalized_emittance_y / (g*beta)
-
-        P = 2*self.beam.current / (alfven_current * (g*beta)**3)
-
         dxdz = xp
-        dxpdz = 2*P / (x + y) + emitt_x*emitt_x / x**3 - K_x*x - \
-                dgdz*xp / (beta*beta*g) - d2gdz2*x / (2*beta*beta*g)
+        dxpdz = 2 * P / (x + y) + emitt_x * emitt_x / x**3 - K_x * x - \
+            dgdz * xp / (beta * beta * g) - d2gdz2 * x / (2 * beta * beta * g)
         dydz = yp
-        dypdz = 2*P / (x + y) + emitt_y*emitt_y / y**3 - K_y*y - \
-                dgdz*yp / (beta*beta*g) - d2gdz2*y / (2*beta*beta*g)
+        dypdz = 2 * P / (x + y) + emitt_y * emitt_y / y**3 - K_y * y - \
+            dgdz * yp / (beta * beta * g) - d2gdz2 * y / (2 * beta * beta * g)
 
@@ -65,4 +65,4 @@ return [dxdz, dxpdz, dydz, dypdz]
     def centroid_prime(self,
-                       z:np.arange,
-                       X:list) -> list:
+                       z: np.arange,
+                       X: list) -> list:
         """Located derivative for further integration
@@ -79,5 +79,7 @@ Kapchinscky equation for centroid trajectory.
 
-        g = self.beam.gamma + self.beam.charge*self.accelerator.Ezdz(z)/mass_rest_electron
-        beta = np.sqrt(1 - 1 / (g*g))
-        p = g*beta*mass_rest_electron*MeV/speed_light
+        g = self.beam.gamma + self.beam.charge * \
+            self.accelerator.Ezdz(z) / consts.mass_rest_electron
+        beta = np.sqrt(1 - 1 / (g * g))
+        p = g * beta * \
+            consts.mass_rest_electron * consts.MeV / consts.speed_light
 
@@ -96,21 +98,25 @@ offset_x = self.accelerator.Dx(z)
         dBzdz = self.accelerator.dBzdz(z)
-        d2Bzdz2 = misc.derivative(self.accelerator.dBzdz, z, dx=self.accelerator.dz, n=1)
+        d2Bzdz2 = misc.derivative(
+            self.accelerator.dBzdz, z, dx=self.accelerator.dz, n=1)
         Gz = self.accelerator.Gz(z)
-        Bz = Bz - d2Bzdz2*r_corr**2/4                          # row remainder
-        Bx = Bx + Gz*y_corr - dBzdz*x_corr/2 + Bz*offset_xp    # row remainder
-        By = By + Gz*x_corr - dBzdz*y_corr/2 + Bz*offset_yp    # row remainder
-        Brho = p/self.beam.charge
+        Bz = Bz - d2Bzdz2 * r_corr**2 / 4
+        Bx = Bx + Gz * y_corr - dBzdz * x_corr / 2 + Bz * offset_xp
+        By = By + Gz * x_corr - dBzdz * y_corr / 2 + Bz * offset_yp
+        Brho = p / self.beam.charge
 
-        Ez = self.accelerator.Ez(z)*MeV
-        dEzdz = self.accelerator.dEzdz(z)*MeV
-        d2Ezdz2 = misc.derivative(self.accelerator.dEzdz, z, dx=self.accelerator.dz, n=1)*MeV
-        Ez = Ez - d2Ezdz2*r_corr**2/4                    # row remainder
-        Ex = - dEzdz*x_corr/2 + Ez*offset_xp             # row remainder
-        Ey = - dEzdz*y_corr/2 + Ez*offset_yp             # row remainder
+        Ez = self.accelerator.Ez(z) * consts.MeV
+        dEzdz = self.accelerator.dEzdz(z) * consts.MeV
+        d2Ezdz2 = misc.derivative(self.accelerator.dEzdz, z,
+                                  dx=self.accelerator.dz, n=1) * consts.MeV
+        Ez = Ez - d2Ezdz2 * r_corr**2 / 4                    # row remainder
+        Ex = - dEzdz * x_corr / 2 + Ez * offset_xp             # row remainder
+        Ey = - dEzdz * y_corr / 2 + Ez * offset_yp             # row remainder
 
         dxdz = xp
-        dxpdz = (Ex - Ez*xp) / (beta*speed_light*Brho) - (By - yp*Bz) / Brho
+        dxpdz = (Ex - Ez * xp) / (beta * consts.speed_light * Brho) - \
+            (By - yp * Bz) / Brho
         dydz = yp
-        dypdz = (Ey - Ez*yp) / (beta*speed_light*Brho) + (Bx - xp*Bz) / Brho
-        dphidz = Bz / (2*Brho)
+        dypdz = (Ey - Ez * yp) / (beta * consts.speed_light * Brho) + \
+            (Bx - xp * Bz) / Brho
+        dphidz = Bz / (2 * Brho)
 
@@ -120,4 +126,4 @@ return [dxdz, dxpdz, dydz, dypdz, dphidz]
     def particle_prime(self,
-                       z:np.arange,
-                       X:list, envelope_x, envelope_y) -> list:
+                       z: np.arange,
+                       X: list, envelope_x, envelope_y) -> list:
         """Located derivative for further integration
@@ -135,37 +141,59 @@ Kapchinscky equation for envelope beam.
         if self.particle.energy == 0.0:
-            g = self.beam.gamma + self.beam.charge*self.accelerator.Ezdz(z)/mass_rest_electron
+            g = self.beam.gamma + self.beam.charge * \
+                self.accelerator.Ezdz(z) / consts.mass_rest_electron
         else:
-            g = self.particle.gamma + self.beam.charge*self.accelerator.Ezdz(z)/mass_rest_electron
-        dgdz = self.beam.charge*self.accelerator.Ez(z)/mass_rest_electron
-        d2gdz2 = self.beam.charge*self.accelerator.dEzdz(z)/mass_rest_electron
-        beta = np.sqrt(1 - 1 / (g*g))
-        p = g*beta*mass_rest_electron
+            g = self.particle.gamma + self.beam.charge * \
+                self.accelerator.Ezdz(z) / consts.mass_rest_electron
+        dgdz = self.beam.charge * \
+            self.accelerator.Ez(z) / consts.mass_rest_electron
+        d2gdz2 = self.beam.charge * \
+            self.accelerator.dEzdz(z) / consts.mass_rest_electron
+        beta = np.sqrt(1 - 1 / (g * g))
+        p = g * beta * consts.mass_rest_electron
 
-        K_s = (self.beam.charge*speed_light*self.accelerator.Bz(z) / (2*p*MeV))**2
-        K_q = (self.beam.charge*speed_light*self.accelerator.Gz(z) / (p*MeV))
+        K_s = (self.beam.charge * consts.speed_light *
+               self.accelerator.Bz(z) / (2 * p * consts.MeV))**2
+        K_q = (self.beam.charge * consts.speed_light *
+               self.accelerator.Gz(z) / (p * consts.MeV))
         K_x = K_s - K_q
         K_y = K_s + K_q
 
-        Brho = g*beta*mass_rest_electron*MeV/speed_light/self.beam.charge
+        Brho = g * beta * \
+            consts.mass_rest_electron * \
+            consts.MeV / consts.speed_light / self.beam.charge
 
-        P = 2*self.beam.current / (alfven_current * (g*beta)**3)
-        if (x*x + y*y > envelope_x(z)**2 + envelope_y(z)**2) and (x != 0.0  and y !=0.0):
+        P = 2 * self.beam.current / (consts.alfven_current * (g * beta)**3)
+        if ((x * x + y * y > envelope_x(z)**2 + envelope_y(z)**2) and
+           (x != 0.0 and y != 0.0)):
             dxdz = xp
-            dxpdz = 2*P * ((envelope_x(z)+envelope_y(z))/2*envelope_x(z)) / x - K_x*x - \
-                    dgdz*xp / (beta*beta*g) - d2gdz2*x / (2*beta*beta*g)
+            dxpdz = 2 * P * \
+                ((envelope_x(z) + envelope_y(z)) / 2 * envelope_x(z)) / x - \
+                K_x * x - \
+                dgdz * xp / (beta * beta * g) - d2gdz2 * \
+                x / (2 * beta * beta * g)
             dydz = yp
-            dypdz = 2*P * ((envelope_x(z)+envelope_y(z))/2*envelope_y(z)) / y - K_y*y - \
-                    dgdz*yp / (beta*beta*g) - d2gdz2*y / (2*beta*beta*g)
+            dypdz = 2 * P * \
+                ((envelope_x(z) + envelope_y(z)) / 2 * envelope_y(z)) / y - \
+                K_y * y - \
+                dgdz * yp / (beta * beta * g) - d2gdz2 * \
+                y / (2 * beta * beta * g)
         else:
             dxdz = xp
-            dxpdz = 2*P / ((envelope_x(z)+envelope_y(z))/2*envelope_x(z)) * x - K_x*x - \
-                    dgdz*xp / (beta*beta*g) - d2gdz2*x / (2*beta*beta*g)
+            dxpdz = 2 * P / \
+                ((envelope_x(z) + envelope_y(z)) / 2 * envelope_x(z)) * x - \
+                K_x * x - \
+                dgdz * xp / (beta * beta * g) - d2gdz2 * \
+                x / (2 * beta * beta * g)
             dydz = yp
-            dypdz = 2*P / ((envelope_x(z)+envelope_y(z))/2*envelope_y(z)) * y - K_y*y - \
-                    dgdz*yp / (beta*beta*g) - d2gdz2*y / (2*beta*beta*g)
+            dypdz = 2 * P / \
+                ((envelope_x(z) + envelope_y(z)) / 2 * envelope_y(z)) * y - \
+                K_y * y - \
+                dgdz * yp / (beta * beta * g) - d2gdz2 * \
+                y / (2 * beta * beta * g)
 
-        dphidz = self.accelerator.Bz(z) / (2*Brho)
+        dphidz = self.accelerator.Bz(z) / (2 * Brho)
 
         return [dxdz, dxpdz, dydz, dypdz, dphidz]
 
+
 class Simulation:
@@ -211,8 +239,8 @@ """Simulation of the envelope beam in the accelerator.
     def track(self, *,
-              particle: bool=False,
-              centroid: bool=False,
-              envelope: bool=True,
-              rtol: float=1e-4,
-              atol: float=1e-7,
-              method: str='RK23'):
+              particle: bool = False,
+              centroid: bool = False,
+              envelope: bool = True,
+              rtol: float = 1e-4,
+              atol: float = 1e-7,
+              method: str = 'RK23'):
         """Tracking!"""
@@ -223,4 +251,12 @@
 
-        self.gamma = self.beam.gamma + self.beam.charge*self.accelerator.Ezdz(self.accelerator.parameter)/mass_rest_electron
-        self.gamma = interpolate.interp1d(self.accelerator.parameter, self.gamma, kind='cubic', fill_value=(0, 0), bounds_error=False)
+        self.gamma = self.beam.gamma + self.beam.charge * \
+            self.accelerator.Ezdz(self.accelerator.parameter) / \
+            consts.mass_rest_electron
+        self.gamma = interpolate.interp1d(
+            self.accelerator.parameter,
+            self.gamma,
+            kind='cubic',
+            fill_value=(0, 0),
+            bounds_error=False
+        )
 
@@ -231,15 +267,47 @@ if envelope:
             # solver
-            beam_envelope = solve_ivp(equations.envelope_prime,
-            t_span=[self.accelerator.parameter[0], self.accelerator.parameter[-1]],
-            y0=X0_beam, t_eval=self.accelerator.parameter, method=method, rtol=rtol, atol=atol).y
+            z_start = self.accelerator.parameter[0]
+            z_finish = self.accelerator.parameter[-1]
+            beam_envelope = solve_ivp(
+                equations.envelope_prime,
+                t_span=[z_start, z_finish],
+                y0=X0_beam,
+                t_eval=self.accelerator.parameter,
+                method=method,
+                rtol=rtol,
+                atol=atol
+            ).y
 
-            self.envelope_x = beam_envelope[0,:]
-            self.envelope_xp = beam_envelope[1,:]
-            self.envelope_y = beam_envelope[2,:]
-            self.envelope_yp = beam_envelope[3,:]
+            self.envelope_x = beam_envelope[0, :]
+            self.envelope_xp = beam_envelope[1, :]
+            self.envelope_y = beam_envelope[2, :]
+            self.envelope_yp = beam_envelope[3, :]
 
-            self.envelope_x = interpolate.interp1d(self.accelerator.parameter, self.envelope_x, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.envelope_xp = interpolate.interp1d(self.accelerator.parameter, self.envelope_xp, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.envelope_y = interpolate.interp1d(self.accelerator.parameter, self.envelope_y, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.envelope_yp = interpolate.interp1d(self.accelerator.parameter, self.envelope_yp, kind='cubic', fill_value=(0, 0), bounds_error=False)
+            self.envelope_x = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.envelope_x,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.envelope_xp = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.envelope_xp,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.envelope_y = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.envelope_y,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.envelope_yp = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.envelope_yp,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
 
@@ -250,17 +318,55 @@ if centroid:
                                     self.beam.larmor_angle])
-            centroid_trajectory = solve_ivp(equations.centroid_prime,
-            t_span=[self.accelerator.parameter[0], self.accelerator.parameter[-1]],
-            y0=X0_centroid, t_eval=self.accelerator.parameter, method=method, rtol=rtol, atol=atol).y
+            z_start = self.accelerator.parameter[0]
+            z_finish = self.accelerator.parameter[-1]
+            centroid_trajectory = solve_ivp(
+                equations.centroid_prime,
+                t_span=[z_start, z_finish],
+                y0=X0_centroid,
+                t_eval=self.accelerator.parameter,
+                method=method,
+                rtol=rtol,
+                atol=atol
+            ).y
 
-            self.centroid_x = centroid_trajectory[0,:]
-            self.centroid_xp = centroid_trajectory[1,:]
-            self.centroid_y = centroid_trajectory[2,:]
-            self.centroid_yp = centroid_trajectory[3,:]
-            phi = self.larmor_angle = centroid_trajectory[4,:]
+            self.centroid_x = centroid_trajectory[0, :]
+            self.centroid_xp = centroid_trajectory[1, :]
+            self.centroid_y = centroid_trajectory[2, :]
+            self.centroid_yp = centroid_trajectory[3, :]
+            phi = self.larmor_angle = centroid_trajectory[4, :]
 
-            self.centroid_x = interpolate.interp1d(self.accelerator.parameter, self.centroid_x, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.centroid_xp = interpolate.interp1d(self.accelerator.parameter, self.centroid_xp, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.centroid_y = interpolate.interp1d(self.accelerator.parameter, self.centroid_y, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.centroid_yp = interpolate.interp1d(self.accelerator.parameter, self.centroid_yp, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.larmor_angle = interpolate.interp1d(self.accelerator.parameter, self.larmor_angle, kind='cubic', fill_value=(0, 0), bounds_error=False)
+            self.centroid_x = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.centroid_x,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.centroid_xp = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.centroid_xp,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.centroid_y = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.centroid_y,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.centroid_yp = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.centroid_yp,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.larmor_angle = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.larmor_angle,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
 
@@ -271,21 +377,65 @@ if particle:
                                     self.particle.larmor_angle])
+
             def wrapper(t, y):
-                return equations.particle_prime(t,y, self.envelope_x, self.envelope_y)
+                return equations.particle_prime(t, y, self.envelope_x,
+                                                self.envelope_y)
 
-            particle_trajectory = solve_ivp(wrapper,
-            t_span=[self.accelerator.parameter[0], self.accelerator.parameter[-1]],
-            y0=X0_particle, t_eval=self.accelerator.parameter, method=method, rtol=rtol, atol=atol).y
+            z_start = self.accelerator.parameter[0]
+            z_finish = self.accelerator.parameter[-1]
+            particle_trajectory = solve_ivp(
+                wrapper,
+                t_span=[z_start, z_finish],
+                y0=X0_particle,
+                t_eval=self.accelerator.parameter,
+                method=method,
+                rtol=rtol,
+                atol=atol
+            ).y
+            psi = self.particle_larmor_angle = particle_trajectory[4, :]
+            self.particle_x = particle_trajectory[0, :] * \
+                np.cos(psi) - particle_trajectory[2, :] * np.sin(psi)
+            self.particle_y = particle_trajectory[0, :] * \
+                np.sin(psi) + particle_trajectory[2, :] * np.cos(psi)
+            self.particle_xp = particle_trajectory[1, :] * \
+                np.cos(psi) - particle_trajectory[3, :] * np.sin(psi)
+            self.particle_yp = particle_trajectory[1, :] * \
+                np.sin(psi) + particle_trajectory[3, :] * np.cos(psi)
 
-            psi = self.particle_larmor_angle = particle_trajectory[4,:]
-            self.particle_x = particle_trajectory[0,:]*np.cos(psi) - particle_trajectory[2,:]*np.sin(psi)
-            self.particle_y = particle_trajectory[0,:]*np.sin(psi) + particle_trajectory[2,:]*np.cos(psi)
-            self.particle_xp = particle_trajectory[1,:]*np.cos(psi) - particle_trajectory[3,:]*np.sin(psi)
-            self.particle_yp = particle_trajectory[1,:]*np.sin(psi) + particle_trajectory[3,:]*np.cos(psi)
+            self.particle_x = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.particle_x,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.particle_xp = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.particle_xp,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.particle_y = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.particle_y,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.particle_yp = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.particle_yp,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
+            self.particle_larmor_angle = interpolate.interp1d(
+                self.accelerator.parameter,
+                self.particle_larmor_angle,
+                kind='cubic',
+                fill_value=(0, 0),
+                bounds_error=False
+            )
 
-            self.particle_x = interpolate.interp1d(self.accelerator.parameter, self.particle_x, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.particle_xp = interpolate.interp1d(self.accelerator.parameter, self.particle_xp, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.particle_y = interpolate.interp1d(self.accelerator.parameter, self.particle_y, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.particle_yp = interpolate.interp1d(self.accelerator.parameter, self.particle_yp, kind='cubic', fill_value=(0, 0), bounds_error=False)
-            self.particle_larmor_angle = interpolate.interp1d(self.accelerator.parameter, self.particle_larmor_angle, kind='cubic', fill_value=(0, 0), bounds_error=False)
 
 Sim = Simulation

PKG-INFO

 Metadata-Version: 2.1
 Name: kenv
-Version: 0.2.3.3
-Summary: Kapchinscky ENVelope (KENV) -
- solver of the Kapchinsky-Vladimirsky envelope equation
+Version: 0.3.0.0
+Summary: Kapchinscky ENVelope (KENV) -  solver of the Kapchinsky-Vladimirsky envelope equation
 Home-page: https://github.com/fuodorov/kenv
@@ -7,0 +6,0 @@ Author: Vyacheslav Fedorov

Alert delta unavailable

Currently unable to show alert delta for PyPI packages.

Improved metrics

Total package byte prevSize

46030

9.72%

Lines of code

990

30.09%