syned 1.0.47__py3-none-any.whl

syned/beamline/optical_elements/ideal_elements/ideal_fzp.py

@@ -0,0 +1,183 @@
+import numpy
+from syned.beamline.optical_elements.ideal_elements.ideal_element import IdealElement
+
+class IdealFZP(IdealElement):
+    """
+    Defines an ideal Fresnel Zone Plate.
+
+    Constructor.
+
+    Parameters
+    ----------
+    name : str, optional
+        The name of the optical element.
+    focusing_direction : int
+        0=None, 1=x (sagittal), 2=z (meridional), 3=2D focusing.
+    focal : float
+        The focal length in meters.
+    nominal_wavelength : float
+        The nominal wavelength in m for where the focal length is defined.
+    diameter : float
+        The FZP diameter in m.
+
+    """
+    def __init__(self,
+                 name="Undefined",
+                 focusing_direction=3,  # 0=None, 1=x (sagittal), 2=z (meridional), 3=2D focusing.
+                 focal=1.0,                 #  focal distance (m)
+                 nominal_wavelength=1e-10,  # nominal wavelength in m
+                 # r0=10.0e-6,                #  inner zone radius (m)
+                 diameter=0.001,            # FZP diameter in m
+                 ):
+        IdealElement.__init__(self, name=name)
+        self._focusing_direction = focusing_direction
+        self._focal = focal
+        self._nominal_wavelength = nominal_wavelength
+        self._diameter = diameter
+
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name"              , "Name"                , ""),
+                    ("boundary_shape"    , ""                    , ""),
+                    ("focusing_direction", "Focusing direction: 0=None, 1=1D along X, 2=1D along Z, 3=2D", ""),
+                    ("focal"             , "Focal length"        , "m"),
+                    ("nominal_wavelength", "Nominal wavelength"  , "m"),
+                    ("diameter"          , "FZP diameter"        , "m"),
+            ] )
+
+    def focusing_direction(self):
+        """
+        Returns the focusing direction.
+
+        Returns
+        -------
+        int
+            0=None,
+            1=1D along X,
+            2=1D along Z,
+            3=2D.
+        """
+        return self._focusing_direction
+
+    def focal(self):
+        """
+        Returns the focal length.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._focal
+
+    def nominal_wavelength(self):
+        """
+        Returns the nominal wavelength.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._nominal_wavelength
+
+    def diameter(self):
+        """
+        Returns the FZP diameter.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._diameter
+
+    #
+    # calculated. The exact expression is rn = sqrt( n lambda f + (n lambda / 2)**2 )
+    #
+    def rn(self):
+        return 0.5 * self.diameter()
+
+    def r0(self):
+        """
+        Returns the innermost radius (approximated calculation r0=sqrt(wavelength * focal)).
+
+        Returns
+        -------
+        float
+
+        """
+        return numpy.sqrt(self.nominal_wavelength() * self.focal())
+
+    def r0_exact(self):
+        """
+        Returns the innermost radius (exact calculation r0=sqrt(wavelength * focal + (wavelength/2)**2)).
+
+        Returns
+        -------
+        float
+
+        """
+        return numpy.sqrt(self.nominal_wavelength() * self.focal() + (0.5 * self.nominal_wavelength())**2)
+
+    def n_vs_r(self, r): # approximated if f >> diameter; eq 855 in Michette
+        """
+        Returns the zone number for a given distance r (approximated calculation).
+
+        Returns
+        -------
+        float
+
+        """
+        return (r ** 2 / self.nominal_wavelength() / self.focal())
+
+    def n_exact_vs_r(self, r): # Exact, solving n from rn = sqrt( n lambda f + (n lambda / 2)**2 )
+        """
+        Returns the zone number for a given distance r
+        (exact calculation solving n from rn = sqrt( n lambda f + (n lambda / 2)**2).
+
+        Returns
+        -------
+        float
+
+        """
+        nn = -2 * self.focal() + 2 * numpy.sqrt(self.focal()**2 + r**2)
+        return nn / self.nominal_wavelength()
+
+    def n(self):
+        """
+        Returns the zone number for a outermost zone (approximated calculation).
+
+        Returns
+        -------
+        float
+
+        """
+        return self.n_vs_r( self.rn() )
+
+    def n_exact(self):
+        """
+        Returns the zone number for a outermost zone (exact calculation using n_exact_vs_r() ).
+
+        Returns
+        -------
+        float
+
+        """
+        return self.n_exact_vs_r(self.rn())
+
+if __name__ == "__main__":
+    fzp = IdealFZP(
+        name = "Undefined",
+        focusing_direction = 3,  # 0=None, 1=x (sagittal), 2=z (meridional), 3=2D focusing.
+        focal = 1.0,  # focal distance (m)
+        nominal_wavelength = 1e-10,  # nominal wavelength in m
+        diameter = 0.001,  # FZP diameter in m
+    )
+
+    print(fzp.info())
+    print("r0, r0_exact: ", fzp.r0(), fzp.r0_exact())
+    print("rn: ", fzp.rn())
+    print("n, n_exact: ", fzp.n(), fzp.n_exact())
+
+

syned/beamline/optical_elements/ideal_elements/ideal_lens.py

@@ -0,0 +1,54 @@
+from syned.beamline.optical_elements.ideal_elements.ideal_element import IdealElement
+
+class IdealLens(IdealElement):
+    """
+    Defines an ideal lens. It converts a plane wave into:
+    * an spherical converging wave (if focal_x=focal_y).
+    * a toroidal converging wave (if focal_x != focal_y).
+    * a cylindrical wave (if focal_x or focal_y is infinity).
+
+    Constructor.
+
+    Parameters
+    ----------
+    name : str, optional
+        The name of the optical element.
+    focal_x : float
+        The focal length in meters along the X direction.
+    focal_y : float
+        The focal length in meters along the Y direction.
+
+    """
+    def __init__(self, name="Undefined", focal_x=1.0, focal_y=1.0):
+        IdealElement.__init__(self, name=name)
+        self._focal_x = focal_x
+        self._focal_y = focal_y
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name"          , "Name"                          , ""),
+                    ("boundary_shape", ""                              , ""),
+                    ("focal_x"       , "Focal length in x [horizontal]", "m" ),
+                    ("focal_y"       , "Focal length in y [vertical]"  , "m" ),
+            ] )
+
+    def focal_x(self):
+        """
+        Returns the focal length in the X direction.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._focal_x
+
+    def focal_y(self):
+        """
+        Returns the focal length in the Y direction.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._focal_y

syned/beamline/optical_elements/ideal_elements/screen.py

@@ -0,0 +1,16 @@
+from syned.beamline.optical_elements.ideal_elements.ideal_element import IdealElement
+
+class Screen(IdealElement):
+    """
+    Defines an ideal screen (a plane perpendiculat to the optical axis).
+
+    Constructor.
+
+    Parameters
+    ----------
+    name : str, optional
+        The name of the optical element.
+
+    """
+    def __init__(self, name="Undefined"):
+        IdealElement.__init__(self, name=name)

syned/beamline/optical_elements/mirrors/__init__.py

@@ -0,0 +1 @@
+

syned/beamline/optical_elements/mirrors/mirror.py

@@ -0,0 +1,39 @@
+from syned.beamline.shape import SurfaceShape
+from syned.beamline.optical_element_with_surface_shape import OpticalElementsWithSurfaceShape
+
+class Mirror(OpticalElementsWithSurfaceShape):
+    """
+    Constructor.
+
+    Parameters
+    ----------
+    name : str
+        The name of the optical element.
+    surface_shape : instance of SurfaceShape, optional
+        The geometry of the crystal surface. if None, it is initialized to SurfaceShape().
+    boundary_shape : instance of BoundaryShape, optional
+        The geometry of the slit aperture. if None, it is initialized to BoundaryShape().
+    coating : str, optional
+        The grating coating material.
+    coating_thickness : float, optional
+        The grating coating thickness in m.
+    """
+    def __init__(self,
+                 name="Undefined",
+                 surface_shape=SurfaceShape(),
+                 boundary_shape=None,
+                 coating=None,
+                 coating_thickness=None):
+
+        super().__init__(name, surface_shape, boundary_shape)
+        self._coating = coating
+        self._coating_thickness = coating_thickness
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name",                "Name" ,                               "" ),
+                    ("surface_shape",       "Surface shape",                       "" ),
+                    ("boundary_shape",      "Boundary shape",                      "" ),
+                    ("coating",             "Coating (element, compound or name)", "" ),
+                    ("coating_thickness",   "Coating thickness",                   "m"),
+            ] )
+

syned/beamline/optical_elements/multilayers/__init__.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# ----------------------------------------------------------------------- #
+# Copyright (c) 2025, UChicago Argonne, LLC. All rights reserved.         #
+#                                                                         #
+# Copyright 2025. UChicago Argonne, LLC. This software was produced       #
+# under U.S. Government contract DE-AC02-06CH11357 for Argonne National   #
+# Laboratory (ANL), which is operated by UChicago Argonne, LLC for the    #
+# U.S. Department of Energy. The U.S. Government has rights to use,       #
+# reproduce, and distribute this software.  NEITHER THE GOVERNMENT NOR    #
+# UChicago Argonne, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR        #
+# ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE.  If software is     #
+# modified to produce derivative works, such modified software should     #
+# be clearly marked, so as not to confuse it with the version available   #
+# from ANL.                                                               #
+#                                                                         #
+# Additionally, redistribution and use in source and binary forms, with   #
+# or without modification, are permitted provided that the following      #
+# conditions are met:                                                     #
+#                                                                         #
+#     * Redistributions of source code must retain the above copyright    #
+#       notice, this list of conditions and the following disclaimer.     #
+#                                                                         #
+#     * Redistributions in binary form must reproduce the above copyright #
+#       notice, this list of conditions and the following disclaimer in   #
+#       the documentation and/or other materials provided with the        #
+#       distribution.                                                     #
+#                                                                         #
+#     * Neither the name of UChicago Argonne, LLC, Argonne National       #
+#       Laboratory, ANL, the U.S. Government, nor the names of its        #
+#       contributors may be used to endorse or promote products derived   #
+#       from this software without specific prior written permission.     #
+#                                                                         #
+# THIS SOFTWARE IS PROVIDED BY UChicago Argonne, LLC AND CONTRIBUTORS     #
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT       #
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS       #
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL UChicago     #
+# Argonne, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,        #
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,    #
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;        #
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER        #
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT      #
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN       #
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         #
+# POSSIBILITY OF SUCH DAMAGE.                                             #
+# ----------------------------------------------------------------------- #

syned/beamline/optical_elements/multilayers/multilayer.py

@@ -0,0 +1,45 @@
+from syned.beamline.shape import SurfaceShape
+from syned.beamline.optical_element_with_surface_shape import OpticalElementsWithSurfaceShape
+
+class Multilayer(OpticalElementsWithSurfaceShape):
+    """
+    Constructor.
+
+    Parameters
+    ----------
+    name : str
+        The name of the optical element.
+    surface_shape : instance of SurfaceShape, optional
+        The geometry of the crystal surface. if None, it is initialized to SurfaceShape().
+    boundary_shape : instance of BoundaryShape, optional
+        The geometry of the slit aperture. if None, it is initialized to BoundaryShape().
+    structure : str, optional
+        The multilayer structure e.g. [B,W]x50+Si.
+    period : float, optional
+        The period of the repeated bilayer in A.
+    Gamma : float, optional
+        The gamma factor.
+    """
+    def __init__(self,
+                 name="Undefined",
+                 surface_shape=SurfaceShape(),
+                 boundary_shape=None,
+                 structure='[B/W]x50+Si',
+                 period=25.0,
+                 Gamma=0.5,
+                 ):
+
+        super().__init__(name, surface_shape, boundary_shape)
+        self._structure = structure
+        self._period = period
+        self._Gamma = Gamma
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name",                "Name" ,                                          "" ),
+                    ("surface_shape",       "Surface shape",                                  "" ),
+                    ("boundary_shape",      "Boundary shape",                                 "" ),
+                    ("structure",           "structure ([Odd,Even]xN+Substrate)",             "" ),
+                    ("period",              "period of the repeated structure",               "A"),
+                    ("Gamma",               "Gamma factor [thickness ratio Even)/(Odd+Even)", ""),
+            ] )
+

syned/beamline/optical_elements/refractors/__init__.py

@@ -0,0 +1 @@
+

syned/beamline/optical_elements/refractors/crl.py

@@ -0,0 +1,79 @@
+from syned.beamline.optical_elements.refractors.lens import Lens
+
+class CRL(Lens):
+    """
+    Defines a Compound refractive lens (CRL). It is composed by a number (n_lens) of identical lenses.
+
+    Constructor.
+
+    Parameters
+    ----------
+    name : str, optional
+        The name of the optical element.
+    n_lens : int, optional
+        The number of (identical) lenses.
+    surface_shape1 : instance of SurfaceShape, optional
+        The geometry of the lens surface 1. if None, it is initialized to SurfaceShape().
+    surface_shape2 : instance of SurfaceShape, optional
+        The geometry of the lens surface 2. if None, it is initialized to SurfaceShape().
+    boundary_shape : instance of BoundaryShape, optional
+        The geometry of the slit aperture. if None, it is initialized to BoundaryShape().
+    material : str
+        A string defining the material within the two surfaces.
+    thickness : float
+        The distance between the two surfaces at the center of the lens in m.
+    piling_thickness : float, optional
+        The piling distance in m, or spatial periodicity in the stack. In other words, the distance from the
+        lens1-surface1 to the lens2-surface1.
+
+    """
+    def __init__(self,
+                 name="Undefined",
+                 n_lens=1,
+                 surface_shape1=None,
+                 surface_shape2=None,
+                 boundary_shape=None,
+                 material="",
+                 thickness=0.0,
+                 piling_thickness=0.0):
+        super().__init__(name=name,
+                         surface_shape1=surface_shape1,
+                         surface_shape2=surface_shape2,
+                         boundary_shape=boundary_shape,
+                         material=material,
+                         thickness=thickness)
+        self._n_lens           = n_lens
+        self._piling_thickness = piling_thickness
+
+        # support text contaning name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name",                "Name" ,                                "" ),
+                    ("n_lens",              "N Lens" ,                              "" ),
+                    ("surface_shapes",      "Surface shapes",                       "" ),
+                    ("boundary_shape",      "Boundary shape",                       "" ),
+                    ("material",            "Material (element, compound or name)", "" ),
+                    ("thickness",           "Thickness",                            "m"),
+                    ("piling_thickness",    "Piling Thickness",                     "m")
+            ] )
+
+    def get_n_lens(self):
+        """
+        Returns the number of lenses.
+
+        Returns
+        -------
+        int
+
+        """
+        return self._n_lens
+
+    def get_piling_thickness(self):
+        """
+        Returns the piling thickness.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._piling_thickness

syned/beamline/optical_elements/refractors/interface.py

@@ -0,0 +1,61 @@
+from syned.beamline.shape import SurfaceShape
+from syned.beamline.optical_element_with_surface_shape import OpticalElementsWithSurfaceShape
+
+class Interface(OpticalElementsWithSurfaceShape):
+    def __init__(self,
+                 name="Undefined",
+                 surface_shape=SurfaceShape(),
+                 boundary_shape=None,
+                 material_object=None,
+                 material_image=None,):
+        """
+        Defines an interface (a surface with different materials in side 1 and side 2).
+
+        Parameters
+        ----------
+        name : str, optional
+            The name of the optical element.
+        surface_shape : instance of SurfaceShape, optional
+            The geometry of the crystal surface. if None, it is initialized to SurfaceShape().
+        boundary_shape : instance of BoundaryShape, optional
+            The geometry of the slit aperture. if None, it is initialized to BoundaryShape().
+        material_object : str, optional
+            The material in side 1 (object side).
+        material_image : str, optional
+            The material in side 2 (object image).
+
+        """
+
+        super().__init__(name, surface_shape, boundary_shape)
+        self._material_object = material_object
+        self._material_image = material_image
+        # support text containg name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name",                "Name" ,                               "" ),
+                    ("surface_shape",       "Surface shape",                       "" ),
+                    ("boundary_shape",      "Boundary shape",                      "" ),
+                    ("material_object",     "Material in object side (element, compound, name or refraction index)", "" ),
+                    ("material_image",      "Material in image side (element, compound, name or refraction index)", ""),
+           ] )
+
+    def get_material_object(self):
+        """
+        Returns the material of side 1 (object).
+
+        Returns
+        -------
+        str
+
+        """
+        return self._material_object
+
+    def get_material_image(self):
+        """
+        Returns the material of side 2 (image).
+
+        Returns
+        -------
+        str
+
+        """
+        return self._material_image

syned/beamline/optical_elements/refractors/lens.py

@@ -0,0 +1,105 @@
+from syned.beamline.optical_element_with_surface_shape import OpticalElementsWithMultipleShapes
+from syned.beamline.shape import Plane
+
+class Lens(OpticalElementsWithMultipleShapes):
+    def __init__(self,
+                 name="Undefined",
+                 surface_shape1=None,
+                 surface_shape2=None,
+                 boundary_shape=None,
+                 material="",
+                 thickness=0.0):
+        """
+        Defines a lens. It is composed by two surfaces (surface_shape1 and surface_shape2) and a material
+        within them.
+
+        Parameters
+        ----------
+        name : str, optional
+            The name of the optical element.
+        surface_shape1 : instance of SurfaceShape, optional
+            The geometry of the lens surface 1. if None, it is initialized to SurfaceShape().
+        surface_shape2 : instance of SurfaceShape, optional
+            The geometry of the lens surface 2. if None, it is initialized to SurfaceShape().
+        boundary_shape : instance of BoundaryShape, optional
+            The geometry of the slit aperture. if None, it is initialized to BoundaryShape().
+        material : str
+            A string defining the material within the two surfaces.
+        thickness : float
+            The distance between the two surfaces at the center of the lens in m.
+
+        """
+
+        if surface_shape1 is None: surface_shape1 = Plane()
+        if surface_shape2 is None: surface_shape2 = Plane()
+
+        super(Lens, self).__init__(name=name,
+                                   boundary_shape=boundary_shape,
+                                   surface_shapes=[surface_shape1, surface_shape2])
+        self._material = material
+        self._thickness = thickness
+
+        # support text contaning name of variable, help text and unit. Will be stored in self._support_dictionary
+        self._set_support_text([
+                    ("name",                "Name" ,                                "" ),
+                    ("surface_shapes",      "Surface shapes",                       ""),
+                    ("boundary_shape",      "Boundary shape",                       "" ),
+                    ("material",            "Material (element, compound or name)", "" ),
+                    ("thickness",           "Thickness",                            "m"),
+            ] )
+
+    def get_thickness(self):
+        """
+        Returns the lens thickness in m.
+
+        Returns
+        -------
+        float
+
+        """
+        return self._thickness
+
+    def get_material(self):
+        """
+        Returns the lens material.
+
+        Returns
+        -------
+        str
+
+        """
+        return self._material
+
+    def get_boundary_shape(self):
+        """
+        Returns the boundary shape.
+
+        Returns
+        -------
+        instance of BoundaryShape
+
+        """
+        return self._boundary_shape
+
+    def get_surface_shape1(self):
+        """
+        Returns the shape of surface 1.
+
+        Returns
+        -------
+        instance of SurfaceShape
+
+        """
+        return self.get_surface_shape(index=0)
+
+    def get_surface_shape2(self):
+        """
+        Returns the shape of surface 2.
+
+        Returns
+        -------
+        instance of SurfaceShape
+
+        """
+        return self.get_surface_shape(index=1)
+