pySRU 0.5.5__py3-none-any.whl

pySRU/ElectricalField.py

@@ -0,0 +1,59 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016 European Synchrotron Radiation Facility
+#
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = ["S Thery, M Glass, M Sanchez del Rio - ESRF ISDD Advanced Analysis and Modelling"]
+__license__ = "MIT"
+__date__ = "31/08/2016"
+
+
+import numpy as np
+class ElectricalField(object):
+   def __init__(self, electrical_field, X, Y, distance):
+      # TODO: maybe check constants if we just calcualte vector potential A
+      self._electrical_field = electrical_field.copy()
+      self._X = X.copy()
+      self._Y = Y.copy()
+      self._distance = distance
+
+   def X(self):
+      return self._X.copy()
+
+   def Y(self):
+      return self._Y.copy()
+
+   def distance(self):
+      return self._distance
+
+   def electrical_field(self):
+      return self._electrical_field.copy()
+
+
+
+   def intensity(self):
+         return np.sum(np.abs(self.electrical_field()) ** 2, axis=-1)
+
+
+
+

pySRU/ElectronBeam.py

@@ -0,0 +1,67 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016 European Synchrotron Radiation Facility
+#
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = ["S Thery, M Glass, M Sanchez del Rio - ESRF ISDD Advanced Analysis and Modelling"]
+__license__ = "MIT"
+__date__ = "31/08/2016"
+
+import numpy as np
+import scipy.constants as codata
+
+
+# container class
+# parameter of the beam
+class ElectronBeam(object):
+    def __init__(self, Electron_energy, I_current):
+        self.Electron_energy=Electron_energy
+        self.I_current=I_current
+
+    def copy(self):
+        return ElectronBeam(Electron_energy=self.Electron_energy, I_current=self.I_current)
+
+    def Lorentz_factor(self):
+        return 1e9*self.Electron_energy / (codata.m_e *  codata.c**2 / codata.e)
+
+    def electron_speed(self):
+        gamma = self.Lorentz_factor()
+        Beta = np.sqrt(1.0 - 1.0 / gamma ** 2)
+        return Beta
+
+    def print_parameters(self):
+        print(' Electron Beam')
+        print('    Electron energy (GeV): %.3f' %self.Electron_energy)
+        print('    Intensity (A): %.3f' % self.I_current)
+        print('    Electron speed : %.10f' %self.electron_speed())
+        print('    Lorentz factor : %.7f' % self.Lorentz_factor())
+
+if __name__ == "__main__" :
+    K = 1.87
+    E = 1.3
+    I = 1.0
+    beam=ElectronBeam(Electron_energy=E, I_current=I)
+
+    beam.print_parameters()
+
+    print('Lorentz factor: %f'%beam.Lorentz_factor())

pySRU/MagneticField.py

@@ -0,0 +1,146 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016 European Synchrotron Radiation Facility
+#
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = ["S Thery, M Glass, M Sanchez del Rio - ESRF ISDD Advanced Analysis and Modelling"]
+__license__ = "MIT"
+__date__ = "31/08/2016"
+
+import numpy as np
+
+
+
+
+
+class MagneticField(object):
+    def __init__(self,Bx,By,Bz):
+        self.Bx = Bx
+        self.By = By
+        self.Bz = Bz
+
+    def copy(self):
+        if type(self.Bx)==np.ndarray:
+            Bx = self.Bx.copy()
+        else :
+            Bx=self.Bx
+        if type(self.By)==np.ndarray:
+            By = self.By.copy()
+        else :
+            By=self.By
+        if type(self.Bz)==np.ndarray:
+            Bz = self.Bz.copy()
+        else :
+            Bz=self.Bz
+        return MagneticField(Bx=Bx, By=By, Bz=Bz)
+
+    #faire une fct aui fait l'interpolation  et elargissement
+    #
+
+    #TODO a modifier
+    # enelarge 2 vector for the interpolation of the magnetic field use in trajectory_undulator_from_magnetic_field2
+    def enlargement_vector_for_interpolation(self,Z,Y ,nb_enlarg=0):
+        dz = Z[1] -Z[0]
+        enlarg_1 = np.linspace(Z[0] - nb_enlarg * dz, Z[0] - dz, nb_enlarg)
+        enlarg_2 = np.linspace(Z[- 1] + dz, Z[- 1] + nb_enlarg * dz, nb_enlarg)
+        Z = np.concatenate((enlarg_1, Z))
+        Z = np.concatenate((Z, enlarg_2))
+        if (type(Y )==np.ndarray) :
+            dy = Y [1] - Y [0]
+            enlarg_1 = np.linspace(Y [0] - nb_enlarg * dz, Y [0] - dy, nb_enlarg)
+            enlarg_2 = np.linspace(Y [- 1] + dy, Y [- 1] + nb_enlarg * dy, nb_enlarg)
+            Y  = np.concatenate((enlarg_1, Y ))
+            Y = np.concatenate((Y , enlarg_2))
+        if (type(self.By)==np.ndarray) :
+            enlarg_3 = np.zeros(nb_enlarg)
+            self.By = np.concatenate((enlarg_3, self.By))
+            self.By = np.concatenate((self.By, enlarg_3))
+        return Z,Y
+
+
+
+
+    def plot_z(self,X,Y,Z,title="Magnetic field",field_component=None):
+        import matplotlib.pyplot as plt
+
+        if ( (field_component == None) or (field_component == 0) or (field_component == 'x') ):
+            plt.plot(Z, self.Bx(z=Z,y=Y,x=X))
+
+            plt.ylabel('Bx [T]')
+            plt.xlabel('Z [m]')
+            plt.title(title+" Bx = f(z) ")
+            plt.show()
+
+        if ( (field_component == None) or (field_component == 1) or (field_component == 'y') ):
+            plt.plot(Z, self.By(z=Z,y=Y,x=X))
+            plt.ylabel('By [T]')
+            plt.xlabel('Z [m]')
+            plt.title(title+" By = f(z) ")
+            plt.show()
+
+        if ( (field_component == None) or (field_component == 2) or (field_component == 'z') ):
+            plt.plot(Z, self.Bz(z=Z,y=Y,x=X))
+            plt.ylabel('Bz [T]')
+            plt.xlabel('Z [m]')
+            plt.title(title+" Bz = f(z) ")
+            plt.show()
+
+# # TODO A CHANGER COMME PLOT_z
+        #TODO quiver plot ?
+#     def plot_y(self):
+#         plt.plot(self.y, self.Bx(self.z, self.y))
+#         plt.title(" Bx = f(y) ")
+#         plt.xlabel('Bx')
+#         plt.ylabel('y')
+#         plt.show()
+#
+#         plt.plot(self.y, self.By(self.z, self.y))
+#         plt.title(" By = f(y) ")
+#         plt.xlabel('By')
+#         plt.ylabel('y')
+#         plt.show()
+#
+#         plt.plot(self.y, self.Bz(self.z, self.y))
+#         plt.title(" Bz = f(y) ")
+#         plt.xlabel('Bz')
+#         plt.ylabel('y')
+#         plt.show()
+
+
+if __name__ == "__main__" :
+    Bx = lambda x,y,z : np.cos(y*z)
+    By = lambda x,y,z : np.sin(x)*np.cos(z)
+    Bz = lambda x,y,z : np.sin(y*z)
+
+    B=MagneticField(Bx=Bx,By=By,Bz=Bz)
+
+    Z=np.linspace(0.0,2.*np.pi,10000)
+    Y=np.linspace(0.0,2.*np.pi,10000)
+    X=np.linspace(0.0,2.*np.pi,10000)
+
+    print('plot X=pi/2 , Y=1 , Z in [0,2 pi]')
+    B.plot_z(X=np.pi*0.5,Y=1.0,Z=Z)
+    print('plot X= pi/2 , Y and Z in [0,2 pi]')
+    B.plot_z(X=np.pi*0.5,Y=Y,Z=Z)
+    print('plot X , Y and Z in [0,2 pi]')
+    B.plot_z(X=X,Y=Y,Z=Z)

pySRU/MagneticStructure.py

@@ -0,0 +1,133 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016 European Synchrotron Radiation Facility
+#
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = ["S Thery, M Glass, M Sanchez del Rio - ESRF ISDD Advanced Analysis and Modelling"]
+__license__ = "MIT"
+__date__ = "31/08/2016"
+
+import numpy as np
+import scipy.constants as codata
+from abc import abstractmethod
+from pySRU.MagneticField import MagneticField
+
+PLANE_UNDULATOR=0
+BENDING_MAGNET=1
+
+class MagneticStructure(object):
+    def __init__(self, magnet_type ):
+        self.magnet_type=magnet_type
+
+    @abstractmethod
+    def copy(self):
+        return
+
+
+    @abstractmethod
+    def print_parameters(self):
+        pass
+
+
+    # magnetic field
+    @abstractmethod
+    def fct_magnetic_field(self, z, y, x, harmonic_number, coordonnee='y'):
+        return 0.0
+
+
+    # TODO la faire plus jolie ?
+    def calculate_magnetic_field(self, Z, Y, X, harmonic_number=1, coordonnee='y'):
+        if (type(Z) == np.ndarray):
+            B = np.zeros_like(Z)
+        else:
+            if (type(Y) == np.ndarray):
+                B = np.zeros_like(Y)
+            else:
+                if (type(X) == np.ndarray):
+                    B = np.zeros_like(X)
+                else:
+                    B = self.fct_magnetic_field(z=Z, y=Y, x=X,
+                                                harmonic_number=harmonic_number, coordonnee=coordonnee)
+
+        if (type(Z) == np.ndarray):
+            if (type(Y) == np.ndarray):
+                if (len(Y) != len(Z)):
+                    raise Exception(' Y and Z must have the same lenght')
+                if (type(X) == np.ndarray):
+                    if (len(X) != len(Z)):
+                        raise Exception(' X and Z must have the same lenght')
+                    for i, Zi in enumerate(Z):
+                        B[i] = self.fct_magnetic_field(z=Zi, y=Y[i], x=X[i],
+                                                   harmonic_number=harmonic_number, coordonnee=coordonnee)
+                else:
+                    for i, Zi in enumerate(Z):
+                        B[i] = self.fct_magnetic_field(z=Zi, y=Y[i], x=X,
+                                                       harmonic_number=harmonic_number, coordonnee=coordonnee)
+            else:
+                if (type(X) == np.ndarray):
+                    if (len(X) != len(Z)):
+                        raise Exception(' X and Z must have the same lenght')
+                    for i, Zi in enumerate(Z):
+                        B[i] = self.fct_magnetic_field(z=Zi, y=Y, x=X[i],
+                                                       harmonic_number=harmonic_number, coordonnee=coordonnee)
+                else:
+                    for i, Zi in enumerate(Z):
+                        B[i] = self.fct_magnetic_field(z=Zi, y=Y, x=X,
+                                                       harmonic_number=harmonic_number, coordonnee=coordonnee)
+        else:
+            if (type(Y) == np.ndarray):
+                if (type(X) == np.ndarray):
+                    if (len(X) != len(Y)):
+                        raise Exception(' X and Z must have the same lenght')
+                for i, Yi in enumerate(Y):
+                    B[i] = self.fct_magnetic_field(z=Z, y=Yi, x=X[i], harmonic_number=harmonic_number,
+                                                   coordonnee=coordonnee)
+            else:
+                if (type(X) == np.ndarray):
+                    for i, Xi in enumerate(X):
+                        B[i] = self.fct_magnetic_field(z=Z, y=Y, x=Xi, harmonic_number=harmonic_number,
+                                                       coordonnee=coordonnee)
+                else:
+                    B = self.fct_magnetic_field(z=Z, y=Y, x=X, harmonic_number=harmonic_number, coordonnee=coordonnee)
+        return B
+
+
+    # a Magnetic structur create a magnetic field
+    # the object MagneticField is create like :
+    # Bx , By , Bz are function R**(3) -> R
+    # this function depend of the magnet type (BendingMagnet or undulator ..)
+    # X, Y can be array or number, they describe the area where we want to work
+    # Z must be an array , it will be use later
+    # they have not necessary the same len
+    # peux etre a changer et ne metrre que les fonctions ... oui
+    def create_magnetic_field(self, harmonic_number=1):
+        By = (lambda z, y, x: self.calculate_magnetic_field(Z=z, Y=y, X=x, harmonic_number=harmonic_number, coordonnee='y'))
+        Bz = (lambda z, y, x: self.calculate_magnetic_field(Z=z, Y=y, X=x, harmonic_number=harmonic_number, coordonnee='z'))
+        Bx = (lambda z, y, x: self.calculate_magnetic_field(Z=z, Y=y, X=x, harmonic_number=harmonic_number, coordonnee='x'))
+        B = MagneticField(Bx, By, Bz)
+        return B
+
+
+
+if __name__ == "__main__" :
+    pass

pySRU/MagneticStructureBendingMagnet.py

@@ -0,0 +1,114 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016 European Synchrotron Radiation Facility
+#
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = ["S Thery, M Glass, M Sanchez del Rio - ESRF ISDD Advanced Analysis and Modelling"]
+__license__ = "MIT"
+__date__ = "31/08/2016"
+
+import numpy as np
+import scipy.constants as codata
+import scipy.special as special
+from pySRU.MagneticStructure import MagneticStructure, PLANE_UNDULATOR,BENDING_MAGNET
+
+
+#TODO changer et mettre la divergeance en parametre ?
+class MagneticStructureBendingMagnet(MagneticStructure):
+    def __init__(self, Bo, horizontale_divergeance,electron_energy=1e9):
+        super(self.__class__, self).__init__(magnet_type=BENDING_MAGNET)
+        self.horizontal_div=horizontale_divergeance
+        self.radius_curv=electron_energy*1e9/(codata.c*Bo)
+        self.length=np.sin(horizontale_divergeance)*self.radius_curv
+        self.Bo = Bo
+
+
+    def copy(self):
+        return MagneticStructureBendingMagnet(length=self.length, Bo=self.Bo)
+
+    def fct_magnetic_field(self, z, y, x, harmonic_number, coordonnee='y'):
+        Zo = self.length * 0.6
+        if coordonnee == 'y' and z >= -Zo and z <= Zo:
+            # codata.m_e * codata.c / codata.e= 0.00170450894933
+            Bo = self.Bo
+
+        else:  # coordonnee == 'z' :
+            Bo = 0.0
+        return Bo
+
+
+    def fct_magnetic_field2(self, z, y, x, harmonic_number, coordonnee='y'):
+        Zo = self.length * 0.5
+        if coordonnee == 'y':
+            # codata.m_e * codata.c / codata.e= 0.00170450894933
+            Bo = self.Bo
+        else:  # coordonnee == 'z' :
+            Bo = 0.0
+
+            # we enelarge the real effect of the magnetic field by 4 lambda_u
+            # on each extremity of the undulator
+        L_magn_field = self.length * 1.5
+
+        # we know considere that if -(L/2 + lambda_u/4) < Z < (L/2 + lambda_u/4)
+        # the magnetic field if a classic cosinus (or sinus)
+        L_cosinus_part = -Zo
+
+        if ((z < -L_magn_field) or (z > L_magn_field)):
+            dB = 0.0
+
+        else:
+            if (z < -L_cosinus_part or z > L_cosinus_part):
+
+                # in this case, we work with a gaussian,
+                # so we shift the coordinate frame for use a central gaussian
+                if z > 0.0:
+                    z_shift = z - L_cosinus_part
+                else:
+                    z_shift = z + L_cosinus_part
+
+                sigma = (L_magn_field - L_cosinus_part) / 5.0
+                # dB= Bo*(1.0-z_shift*self.get_L()**2/2.0)*np.exp(-0.5*(z_shift/sigma)**2)
+                dB = Bo * np.exp(-0.5 * (z_shift / sigma) ** 2)
+            else:
+                # in this case we work in the cosinus part
+                dB = Bo
+        return dB
+
+
+
+    def print_parameters(self):
+        print(" Magnetic Structure (Bending Magnet):")
+        print('    length : %.5f (m)'%self.length)
+        print('    magnetic_field_strength : %.5f'%self.Bo)
+
+
+if __name__ == "__main__" :
+
+    BM = MagneticStructureBendingMagnet(Bo=0.85, length=1e-3 * 20.0)
+
+    print('bending magnet test :')
+    BM.print_parameters()
+    B = BM.create_magnetic_field()
+    Z=np.linspace(-BM.length/2.0,BM.length/2.0,10000)
+    B.plot_z(Z=Z,Y=0.0,X=0.0)
+

pySRU/MagneticStructureUndulatorPlane.py

@@ -0,0 +1,145 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016 European Synchrotron Radiation Facility
+#
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = ["S Thery, M Glass, M Sanchez del Rio - ESRF ISDD Advanced Analysis and Modelling"]
+__license__ = "MIT"
+__date__ = "31/08/2016"
+
+import numpy as np
+import scipy.constants as codata
+from scipy.special import jn,yn,jv,yv
+from pySRU.MagneticField import MagneticField
+from pySRU.MagneticStructure import MagneticStructure , PLANE_UNDULATOR,BENDING_MAGNET
+
+
+
+class MagneticStructureUndulatorPlane(MagneticStructure):
+    def __init__(self, K, period_length, length):
+        super(self.__class__, self).__init__(magnet_type=PLANE_UNDULATOR)
+        self.K = K
+        self.period_length = period_length
+        self.length=length
+
+    def copy(self):
+        return MagneticStructureUndulatorPlane(K=self.K, period_length=self.period_length, length=self.length)
+
+    def fct_magnetic_field(self, z, y, x, harmonic_number, coordonnee='y'):
+        lambda_h = self.period_length / harmonic_number
+        ku = 2.0 * np.pi / self.period_length
+
+        if coordonnee == 'x':
+            dB = 0.0
+        else:
+            # codata.m_e * codata.c / codata.e= 0.00170450894933
+            K_to_B = ku * codata.m_e * codata.c / codata.e
+            if coordonnee == 'y':
+
+                Bo = (self.K * K_to_B) * np.cosh(ku * y)
+                # print(Bo)
+                f_base = np.cos
+            else:  # coordonnee == 'z' :
+                Bo = -(self.K * K_to_B) * np.sinh(ku * y)
+                f_base = np.sin
+
+            # we enelarge the real effect of the magnetic field by 4 lambda_u
+            # on each extremity of the undulator
+            L_magn_field = self.length / 2.0 + 4.0 * self.period_length
+
+            # we know considere that if -(L/2 + lambda_u/4) < Z < (L/2 + lambda_u/4)
+            # the magnetic field if a classic cosinus (or sinus)
+            if coordonnee == 'y':
+                a1 = self.length / self.period_length \
+                     - np.floor(self.period_number())
+                a2 = (0.25 - a1 / 2.0)
+                L_cosinus_part = self.length / 2.0 \
+                                 + self.period_length * a2
+
+            else:
+                L_cosinus_part = self.length / 2.0
+
+            if ((z < -L_magn_field) or (z > L_magn_field)):
+                dB = 0.0
+
+            else:
+                if (z < -L_cosinus_part or z > L_cosinus_part):
+
+                    # in this case, we work with a gaussian,
+                    # so we shift the coordinate frame for use a central gaussian
+                    if z < -L_cosinus_part:
+                        sign = 1
+                    else:  # z> L_cosinus_part
+                        sign = -1
+
+                    shift_z = z + sign * L_cosinus_part
+
+                    p = 2.0 * np.pi ** 2 / (3.0 * lambda_h ** 2)
+                    dB = ((2.0 * np.pi * Bo / lambda_h) * shift_z) * (
+                    1.0 - 4.0 * np.pi ** 2 * shift_z ** 2 / (9.0 * lambda_h ** 2)
+                    ) * np.exp(-p * shift_z ** 2)
+
+                    # test du signe
+                    z_test = sign * (-L_cosinus_part + lambda_h / 4.0)
+                    test_trig = f_base(ku * z_test)
+                    if (sign * test_trig < 0):
+                        dB = -dB
+
+                else:
+                    # in this case we work in the cosinus part
+                    dB = Bo * f_base(ku * z)
+
+        return dB
+
+
+    def print_parameters(self):
+        print(' Magnetic Structure (Plane Undulator)')
+        print('    K : %.2f'%(self.K))
+        print('    period lenght : %.3f' % (self.period_length))
+        print('    lenght : %.2f'% (self.length))
+        print('    number of periods : %d (L/lambdau=%.2f)' % (int(self.period_number()),self.period_number()))
+        print('    magntic field intensity: %.2f'% (self.magnetic_field_strength()))
+
+    def period_number(self):
+        return self.length / self.period_length
+
+    def magnetic_field_strength(self):
+        Bo = (2.0 * np.pi * codata.m_e * codata.c * self.K) / (
+            self.period_length * codata.e)
+        return Bo
+
+if __name__ == "__main__" :
+    und_test = MagneticStructureUndulatorPlane(K=1.87, period_length=0.035, length=0.035 * 14)
+    ESRF18 = MagneticStructureUndulatorPlane(K=1.68, period_length=0.018, length=2.0)
+
+    print('undulator test :')
+    und_test.print_parameters()
+    B=und_test.create_magnetic_field()
+    Z=np.linspace(-und_test.length/2.0,und_test.length/2.0,10000)
+    B.plot_z(Z=Z,Y=0.0,X=0.0)
+
+    print('undulator ESRF18 :')
+    ESRF18.print_parameters()
+    B=ESRF18.create_magnetic_field()
+    Z=np.linspace(-ESRF18.length/2.0,ESRF18.length/2.0,10000)
+    B.plot_z(Z=Z,Y=0.0,X=0.0)