syned 1.0.47__py3-none-any.whl

syned/storage_ring/empty_light_source.py

@@ -0,0 +1,40 @@
+"""
+Base class for LighSource, which contains:
+    - a name
+    - an electron beam
+    - a magnetic structure
+
+"""
+from syned.syned_object import SynedObject
+
+
+class EmptyLightSource(SynedObject):
+    """
+    Defines an empty light source. This is for creating "movable" beamlines (using Beamline()). These are beamlines
+    that do not have a particular light source.
+
+    Parameters
+    ----------
+    name : str, optional
+        The name of the (empty) light source.
+
+    """
+    def __init__(self, name="Empty"):
+        self._name               = name
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name",              "Name",""),
+            ] )
+
+
+    def get_name(self):
+        """
+        Returns the name of the light source.
+
+        Returns
+        -------
+        str
+
+        """
+        return self._name
+

syned/storage_ring/light_source.py

@@ -0,0 +1,90 @@
+"""
+
+
+"""
+from syned.syned_object import SynedObject
+from syned.storage_ring.magnetic_structure import MagneticStructure
+from syned.storage_ring.electron_beam import ElectronBeam
+
+class LightSource(SynedObject):
+    """
+    Base class for LighSource. A light source contains:
+    * a name
+    * an electron beam
+    * a magnetic structure
+
+    Parameters
+    ----------
+    name : str, optional
+        The light source name.
+    electron_beam : instance of ElectronBeam, optional
+        The electron beam. If None, it is initialized with ElectronBeam().
+    magnetic_structure : instance of MagneticStructure, optional
+        The electron beam. If None, it is initialized with MagneticStructure().
+
+    """
+    def __init__(self, name="Undefined", electron_beam=None, magnetic_structure=None):
+        self._name = name
+        if electron_beam is None:
+            self._electron_beam = ElectronBeam()
+        else:
+            self._electron_beam      = electron_beam
+        if magnetic_structure is None:
+            self._magnetic_structure = MagneticStructure()
+        else:
+            self._magnetic_structure = magnetic_structure
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name",              "Name",""),
+                    ("electron_beam",     "Electron Beam",""),
+                    ("magnetic_structure","Magnetic Strtructure",""),
+            ] )
+
+
+    def get_name(self):
+        """
+        Returns the name of the light source.
+
+        Returns
+        -------
+        str
+
+        """
+        return self._name
+
+    def get_electron_beam(self):
+        """
+        Returns the electron beam.
+
+        Returns
+        -------
+        instance of ElectronBeam
+
+        """
+        return self._electron_beam
+
+    def get_magnetic_structure(self):
+        """
+        Returns the magnetic structure.
+
+        Returns
+        -------
+        instance of MagneticStructure
+
+        """
+        return self._magnetic_structure
+
+
+
+
+if __name__ == "__main__":
+
+    from syned.storage_ring.magnetic_structures.undulator import Undulator
+
+    eb = ElectronBeam.initialize_as_pencil_beam( energy_in_GeV=2.0,energy_spread=0.0,current=0.5)
+    ms = Undulator.initialize_as_vertical_undulator( K=1.8, period_length=0.038, periods_number=56.0 )
+
+    light_source = LightSource(name="",electron_beam=eb,magnetic_structure=ms)
+
+    print(light_source.info())
+

syned/storage_ring/magnetic_structure.py

@@ -0,0 +1,8 @@
+from syned.syned_object import SynedObject
+
+class MagneticStructure(SynedObject):
+    """
+    Base clase for magnetic structures (from where BM, Wiggler and Undulator will heritate)
+    """
+    def __init__(self):
+        super().__init__()

syned/storage_ring/magnetic_structures/__init__.py

@@ -0,0 +1 @@
+

syned/storage_ring/magnetic_structures/bending_magnet.py

@@ -0,0 +1,329 @@
+"""
+Base class for a Bending Magnet
+
+
+"""
+from syned.storage_ring.magnetic_structure import MagneticStructure
+import numpy
+import scipy.constants as codata
+
+class BendingMagnet(MagneticStructure):
+    """
+    Constructor.
+
+    Parameters
+    ----------
+    radius : float, optional
+        Physical Radius/curvature of the magnet in m.
+    magnetic_field : float, optional
+         Magnetic field strength in T.
+    length : float, optional
+        physical length of the bending magnet (along the arc) in m.
+
+    """
+    def __init__(self, radius=1.0, magnetic_field=1.0, length=1.0):
+        MagneticStructure.__init__(self)
+        self._radius         = radius
+        self._magnetic_field = magnetic_field
+        self._length         = length
+
+        # support text contaning name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("radius"          , "Radius of bending magnet" , "m"    ),
+                    ("magnetic_field"  , "Magnetic field",            "T"    ),
+                    ("length"          , "Bending magnet length",     "m"   ),
+            ] )
+
+    #
+    #methods for practical calculations
+    #
+    @classmethod
+    def initialize_from_magnetic_field_divergence_and_electron_energy(cls,
+                                                                      magnetic_field=1.0,
+                                                                      divergence=1e-3,
+                                                                      electron_energy_in_GeV=1.0,
+                                                                      **params):
+        """
+        Returns an bending magnet from the magnetic field and electron energy.
+
+        Parameters
+        ----------
+        magnetic_field : float, optional
+             Magnetic field strength in T.
+        divergence : float, optional
+            The beam divergence also corresponding to the BM angle in rad.
+        electron_energy_in_GeV : float, optional
+            The electron beam energy in GeV.
+
+        params :
+            Other parameters accepted by BendingMagnet.
+
+        Returns
+        -------
+        instance of BendingMagnet
+
+        """
+        magnetic_radius = cls.calculate_magnetic_radius(magnetic_field, electron_energy_in_GeV)
+
+        return cls(magnetic_radius, magnetic_field, numpy.abs(divergence * magnetic_radius), **params)
+
+    @classmethod
+    def initialize_from_magnetic_radius_divergence_and_electron_energy(cls,
+                                                                       magnetic_radius=10.0,
+                                                                       divergence=1e-3,
+                                                                       electron_energy_in_GeV=1.0,
+                                                                       **params):
+        """
+        Returns an bending magnet from the magnetic radius and electron energy.
+
+        Parameters
+        ----------
+        magnetic_radius : float, optional
+             Magnetic radius in m.
+        divergence : float, optional
+            The beam divergence also corresponding to the BM angle in rad.
+        electron_energy_in_GeV : float, optional
+            The electron beam energy in GeV.
+
+        params :
+            Other parameters accepted by BendingMagnet.
+
+        Returns
+        -------
+        instance of BendingMagnet
+
+        """
+        magnetic_field = cls.calculate_magnetic_field(magnetic_radius, electron_energy_in_GeV)
+
+        return cls(magnetic_radius,magnetic_field,numpy.abs(divergence * magnetic_radius), **params)
+
+
+    def length(self):
+        """
+        returns the BM length in m.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._length
+
+    def magnetic_field(self):
+        """
+        Returns the bagnetic field in T.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._magnetic_field
+
+    def radius(self):
+        """
+        Returns the BM radius in m.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._radius
+
+    def horizontal_divergence(self):
+        """
+        returns the horizontal divergence in rad.
+
+        Returns
+        -------
+        float
+
+        """
+        return numpy.abs(self.length()/self.radius())
+
+    def get_magnetic_field(self, electron_energy_in_GeV):
+        """
+        returns magnetic field in T (from the magnetic radius and electron energy).
+
+        Parameters
+        ----------
+        electron_energy_in_GeV : float, optional
+            The electron beam energy in GeV.
+
+        Returns
+        -------
+        float
+
+        """
+        return BendingMagnet.calculate_magnetic_field(self._radius, electron_energy_in_GeV)
+
+    def get_magnetic_radius(self, electron_energy_in_GeV):
+        """
+        Calculates magnetic radius (from the magnetic field and electron energy).
+
+        Parameters
+        ----------
+        electron_energy_in_GeV : float, optional
+            The electron beam energy in GeV.
+
+        Returns
+        -------
+        float
+
+        """
+        return BendingMagnet.calculate_magnetic_radius(self._magnetic_field, electron_energy_in_GeV)
+
+
+    def get_critical_energy(self, electron_energy_in_GeV, method=1):
+        """
+        Returns the photon critical energy in eV.
+
+        Parameters
+        ----------
+        electron_energy_in_GeV : float, optional
+            The electron beam energy in GeV.
+        method : int, optional
+            0= uses magnetic radius, 1=uses magnetic field
+
+        Returns
+        -------
+        float
+
+        """
+        if method == 0:
+            return BendingMagnet.calculate_critical_energy(self._radius, electron_energy_in_GeV)
+        else:
+            return BendingMagnet.calculate_critical_energy_from_magnetic_field(self._magnetic_field, electron_energy_in_GeV)
+
+
+
+    # for equations, see for example https://people.eecs.berkeley.edu/~attwood/srms/2007/Lec09.pdf
+    @classmethod
+    def calculate_magnetic_field(cls, magnetic_radius, electron_energy_in_GeV):
+        """
+        Calculates magnetic field from magnetic radius and electron energy.
+
+        Parameters
+        ----------
+        magnetic_radius : float
+             Magnetic radius in m.
+        electron_energy_in_GeV : float
+            The electron beam energy in GeV.
+
+        Returns
+        -------
+        float
+            The magnetic field in T.
+
+        References
+        ----------
+        See, for example, https://people.eecs.berkeley.edu/~attwood/srms/2007/Lec09.pdf
+
+        """
+        # return 3.334728*electron_energy_in_GeV/magnetic_radius
+        return 1e9 / codata.c * electron_energy_in_GeV / magnetic_radius
+
+    @classmethod
+    def calculate_magnetic_radius(cls, magnetic_field, electron_energy_in_GeV):
+        """
+        Calculates magnetic radius from magnetic field and electron energy.
+
+        Parameters
+        ----------
+        magnetic_field : float
+             Magnetic field in T.
+        electron_energy_in_GeV : float
+            The electron beam energy in GeV.
+
+        Returns
+        -------
+        float
+            The magnetic radius in m.
+
+        References
+        ----------
+        See, for example, https://people.eecs.berkeley.edu/~attwood/srms/2007/Lec09.pdf
+
+        """
+        # return 3.334728*electron_energy_in_GeV/magnetic_field
+        return 1e9 / codata.c * electron_energy_in_GeV / magnetic_field
+
+    @classmethod
+    def calculate_critical_energy(cls, magnetic_radius, electron_energy_in_GeV):
+        """
+        Calculates the photon critical energy from magnetic radius and electron energy.
+
+        Parameters
+        ----------
+        magnetic_radius : float
+             Magnetic radius in m.
+        electron_energy_in_GeV : float
+            The electron beam energy in GeV.
+
+        Returns
+        -------
+        float
+            The photon critical energy in eV.
+
+        References
+        ----------
+        See, for example, https://people.eecs.berkeley.edu/~attwood/srms/2007/Lec09.pdf
+
+        """
+        # omega = 3 g3 c / (2r)
+        gamma = 1e9 * electron_energy_in_GeV / (codata.m_e *  codata.c**2 / codata.e)
+        critical_energy_J = 3 * codata.c * codata.hbar * gamma**3 / (2 * numpy.abs(magnetic_radius))
+        critical_energy_eV = critical_energy_J / codata.e
+        return critical_energy_eV
+
+    @classmethod
+    def calculate_critical_energy_from_magnetic_field(cls, magnetic_field, electron_energy_in_GeV):
+        """
+        Calculates the photon critical energy from magnetic field and electron energy.
+
+        Parameters
+        ----------
+        magnetic_field : float
+             Magnetic field in T.
+        electron_energy_in_GeV : float
+            The electron beam energy in GeV.
+
+        Returns
+        -------
+        float
+            The critical energy in eV.
+
+        References
+        ----------
+        See, for example, https://people.eecs.berkeley.edu/~attwood/srms/2007/Lec09.pdf
+
+        """
+        # omega = 3 g3 c / (2r)
+        magnetic_radius = cls.calculate_magnetic_radius(magnetic_field, electron_energy_in_GeV)
+        return cls.calculate_critical_energy(magnetic_radius, electron_energy_in_GeV)
+
+
+if __name__ == "__main__":
+    print("input for ESRF: ")
+    B = BendingMagnet.calculate_magnetic_field(25.0,6.04)
+    print(">> B = ",B)
+    print(">> R = ",BendingMagnet.calculate_magnetic_radius(B,6.04))
+    print(">> Ec = ",BendingMagnet.calculate_critical_energy(25.0,6.04))
+    print(">> Ec = ",BendingMagnet.calculate_critical_energy_from_magnetic_field(B, 6.04))
+    BB = BendingMagnet.calculate_magnetic_radius (BendingMagnet.calculate_magnetic_radius (B,6.04),6.04)
+    RR = BendingMagnet.calculate_magnetic_radius(BendingMagnet.calculate_magnetic_field(25.0,6.04), 6.04)
+    assert(BB == B)
+    assert(RR == 25.0)
+
+
+    print("input for ALS: ")
+    B = BendingMagnet.calculate_magnetic_field(5.0,1.9)
+    print(">> B = ",B)
+    print(">> R = ",BendingMagnet.calculate_magnetic_radius (B,1.9))
+    print(">> Ec = ",BendingMagnet.calculate_critical_energy(5.0,1.9))
+    print(">> Ec = ",BendingMagnet.calculate_critical_energy_from_magnetic_field(B, 1.9))
+    BB = BendingMagnet.calculate_magnetic_radius (BendingMagnet.calculate_magnetic_radius (B,1.9),1.9)
+    RR = BendingMagnet.calculate_magnetic_radius(BendingMagnet.calculate_magnetic_field(5.0, 1.9), 1.9)
+    assert(BB == B)
+    assert(RR == 5.0)

syned/storage_ring/magnetic_structures/insertion_device.py

@@ -0,0 +1,169 @@
+"""
+
+Base class for all insertion devices: wiggler, undulator
+
+"""
+
+from numpy import pi
+import scipy.constants as codata
+
+from syned.storage_ring.magnetic_structure import MagneticStructure
+
+class InsertionDevice(MagneticStructure):
+    """
+    Base clase for the Insertion Device (ID) (common class for wigglers and undulators).
+
+    Parameters
+    ----------
+    K_vertical : float, optional
+        The deflection K parameter corresponding to magnetic field in the vertical direction.
+    K_horizontal : float, optional
+        The deflection K parameter corresponding to magnetic field in the horizontal direction.
+    period_length : float, optional
+        The ID period in m.
+    number_of_periods : float, optional
+        The number of periods. It may be a float, considering that number_of_periods = ID_length / period_length.
+
+    """
+    def __init__(self,
+                 K_vertical        = 0.0,
+                 K_horizontal      = 0.0,
+                 period_length     = 0.0,
+                 number_of_periods = 1.0):
+        MagneticStructure.__init__(self)
+
+        self._K_vertical = K_vertical
+        self._K_horizontal = K_horizontal
+        self._period_length = period_length
+        self._number_of_periods = number_of_periods
+
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("K_vertical"          , "K value (vertical)"  , ""    ),
+                    ("K_horizontal"        , "K value (horizontal)", ""    ),
+                    ("period_length"       , "Period length"       , "m"   ),
+                    ("number_of_periods"   , "Number of periods"   , ""    ),
+            ] )
+
+    def K_vertical(self):
+        """
+        Returns K vertical.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._K_vertical
+
+    def K_horizontal(self):
+        """
+        Returns K horizontal.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._K_horizontal
+
+    def period_length(self):
+        """
+        Returns the ID period in m.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._period_length
+
+    def number_of_periods(self):
+        """
+        Returns the number of periods.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._number_of_periods
+
+
+    #
+    # some easy calculations
+    #
+
+    def K(self):
+        """
+        Returns K vertical.
+
+        Returns
+        -------
+        float
+
+        """
+        return self.K_vertical()
+
+    def length(self):
+        """
+        Returns the ID length in m.
+
+        Returns
+        -------
+        float
+
+        """
+        return self.number_of_periods() * self.period_length()
+
+    def magnetic_field_vertical(self):
+        """
+        Returns the peak magnetic field in T in the vertical direction.
+
+        Returns
+        -------
+        float
+
+        """
+        return self.__magnetic_field_from_K(self.K_vertical())
+
+    def magnetic_field_horizontal(self):
+        """
+        Returns the peak magnetic field in T in the horizontal direction.
+
+        Returns
+        -------
+        float
+
+        """
+        return self.__magnetic_field_from_K(self.K_horizontal())
+
+    def set_K_vertical_from_magnetic_field(self, B_vertical):
+        """
+        Set the vertical K value given the corresponding peak magnetic field.
+
+        Parameters
+        ----------
+        B_vertical : float
+            Peak magnetic field in T.
+
+        """
+        self._K_vertical = self.__K_from_magnetic_field(B_vertical)
+
+    def set_K_horizontal_from_magnetic_field(self, B_horizontal):
+        """
+        Set the horizontal K value given the corresponding peak magnetic field.
+
+        Parameters
+        ----------
+        B_vertical : float
+            Peak magnetic field in T.
+
+        """
+        self._K_horizontal = self.__K_from_magnetic_field(B_horizontal)
+
+    def __magnetic_field_from_K(self, K):
+        return K * 2 * pi * codata.m_e * codata.c / (codata.e * self.period_length())
+
+    def __K_from_magnetic_field(self, B):
+        return B /(2 * pi * codata.m_e * codata.c / (codata.e * self.period_length()))