Merge pull request #259 from hamogu/small_fixes

Small_fixes and add CircularBaffle

Author: hamogu

CHANGES.rst

@@ -5,6 +5,8 @@ New Features
 ^^^^^^^^^^^^
 - Make X3D output compatible with X_ITE. This includes cleanup up of a few pieces
   that X3DOM is not strict about. [#253]
+- Add a new class `marxs.optics.CircularBaffle` that implements a baffle with a circular
+  hole. [#258]
 
 API Changes
 ^^^^^^^^^^^

docs/conventions.rst

@@ -7,7 +7,7 @@ Coordinates, physical units and polarization
 
 Coordinate system
 =================
-Marxs employs a cartesian coordinate system. All optical elements can be freely placed at any position
+Marxs employs a Cartesian coordinate system. All optical elements can be freely placed at any position
 and any angle in this space, but we recommend the following conventions for simplicity (examples and
 predefined missions in this package follow those conventions as far as possible):
 
@@ -20,7 +20,7 @@ Marxs uses `homogeneous coordinates <https://en.wikipedia.org/wiki/Homogeneous_c
 describe position and direction in a 4 dimensional coordinate space, for example
 :math:`[3, 0, 0, 1]` describes a point at x=3, y=0 and z=0; :math:`[3, 0, 0, 0]` describes the
 vector from the origin to that point. Homogeneous coordinates have one important advantage compared
-with a normal 3-d description of Euklidean space: In homogeneous coordinates, rotation, zoom, and
+with a normal 3-d description of Euclidean space: In homogeneous coordinates, rotation, zoom, and
 translations together can be described by a :math:`[4, 4]` matrix and several of these operations can
 be chained simply by multiplying the matrices.
 
@@ -139,7 +139,7 @@ polarization.
 		    (2011) <https://doi.org/10.1364/AO.50.002855>`_
 
 .. [Yun_2011] `Polarization Ray Tracing: G. Yun, University of Arizona, dissertation <http://hdl.handle.net/10150/202979>`_
-  
+
 Physical units
 ==============
 MARXS uses `astropy units

docs/newopticalelements.rst

@@ -75,6 +75,11 @@ Above, we discussed elements that are physically present, such as mirrors or det
   ...     return photons
   >>> photons = backupcopy(photons)
 
+.. testcleanup::
+
+    >>> import os
+    >>> os.remove('backup.fits')
+
 Why have we chosen to return a copy of photons here, although no value in the photon list was changed? This allows us to sneak in the new function into a list of optical elements::
 
   >>> from marxs import simulator

marxs/analysis/coords.py

@@ -64,7 +64,7 @@ def facet_table(container, project_plane=ProjectOntoPlane()):
     -------
     facettab : `astropy.table.Table`
         Table with facet properties.
-        All output columns are prevaced with "facet_" to avoid a clash with columns likely
+        All output columns are prefaced with "facet_" to avoid a clash with columns likely
         to be found in photon tables. That enables easy merging of facet tables with photon tables
         to add the properties of a facet that the photon passed through into the photon table
         like so:

marxs/base/base.py

@@ -194,7 +194,7 @@ def check_energy_consistent(photons):
 class SimulationSequenceElement(MarxsElement):
     '''Base class for all elements in a simulation that processes photons.'''
 
-    output_columns = []
+    output_columns: list[str] = []
     '''This is a list of strings that names the output properties.
 
     This gives the names of the output properties from this optical
@@ -247,7 +247,7 @@ def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
     def add_output_cols(self, photons, colnames=[]):
-        '''Add output columns to the photon array.
+        """Add output columns to the photon array.
 
         This function takes the column names that are added to ``photons`` from
         several sources:
@@ -262,12 +262,12 @@ def add_output_cols(self, photons, colnames=[]):
             Table columns are added to.
         colnames : list of elements
             Each element can be a string (in this case a float column with
-            initial value ``np.nan`` is added) or a dictionay of arguments
-            for `astropy.table.column.Column`. If the dictionay has a keys
+            initial value ``np.nan`` is added) or a dictionary of arguments
+            for `astropy.table.column.Column`. If the dictionary has a keys
             "value" then the column will be initialized to that value.
             Column names to be added; in addition several object properties can
             be used to set the column names, see description above.
-        '''
+        """
         for n in self.output_columns + colnames:
             if (n is not None) and (n not in photons.colnames):
                 if not isinstance(n, dict):

marxs/design/bendgratings.py

@@ -24,20 +24,20 @@
 
 
 def bend_gratings(gratings, radius):
-    '''Bend gratings to follow the Rowland cirle.
+    """Bend gratings to follow the Rowland circle.
 
     Gratings are bend in one direction (the dispersion direction) only.
 
     The numerical procedure used to calculate the bending takes the central ray as
-    a fixed ppoint assuming that the central ray always goes to the correct position!
+    a fixed point assuming that the central ray always goes to the correct position!
 
     Parameters
     ----------
     gratings : list
         List of gratings to be bend
     radius : float
-        Radius of the newly bend gratings
-    '''
+        Radius of the newly bent gratings
+    """
     for e in gratings:
         t, rot, z, s = decompose(e.geometry.pos4d)
         d_phi = np.arctan(z[1] / radius)

marxs/design/tolerancing.py

@@ -436,7 +436,7 @@ def run_tolerances_for_energies2(source, energies, instrum, cls, wigglefunc,
     '''
     ind = instrum.first_of_class_top_level(cls, subclass_ok)
     if ind is None:
-        raise Exception(f'{cls} nor part of {instrum}')
+        raise Exception(f"{cls} not part of {instrum}")
 
     tab = run_tolerances_for_energies(source, energies,
                                       Sequence(elements=instrum.elements[:ind]),

marxs/math/geometry.py

@@ -106,19 +106,19 @@ def __init__(self, kwargs={}):
         super().__init__(kwargs=kwargs)
 
     def __getitem__(self, key):
-        '''This function wraps access to the pos4d matrix.
+        """This function wraps access to the pos4d matrix.
 
         This is mostly a convenience method that gives access to
         vectors from the ``pos4d`` matrix in familiar terms with
         string labels:
 
-        - ``center``: The ``center`` is the origin of the local coordiante system
-          of the optical elemement. Typically, if will be the center of the
+        - ``center``: The ``center`` is the origin of the local coordinate system
+          of the optical element. Typically, if will be the center of the
           active plane, e.g. the center of the mirror surface.
         - :math:`\hat v_{y,z}`: The box stretches in the y and z direction for
           :math:`\pm \hat v_y` and :math:`\pm \hat v_z`. In optics, the relevant
           interaction often happens on a surface, e.g. the surface of a mirror or
-          of a reflection grating. In the defaul configuration, this surface is in
+          of a reflection grating. In the default configuration, this surface is in
           the yz-plane.
         - :math:`\hat v_x`: The thickness of the box is not as important in many
           cases,
@@ -138,7 +138,7 @@ def __getitem__(self, key):
         mirror does not really have a "plane").
         Access through this method is slower than direct indexing of ``self.pos4d``.
 
-        '''
+        """
 
         if key == 'center':
             return self.pos4d[:, 3]
@@ -160,7 +160,7 @@ def __getitem__(self, key):
             return val
 
     def intersect(self, dir, pos):
-        '''Calculate the intersection point between a ray and the element
+        """Calculate the intersection point between a ray and the element
 
         Parameters
         ----------
@@ -177,24 +177,24 @@ def intersect(self, dir, pos):
             homogeneous coordinates of the intersection point. Values are set
             to ``np.nan`` if no intersection point is found.
         interpos_local : `numpy.ndarray` of shape (N, 2)
-            y and z coordinates in the coordiante system of the active plane.
-        '''
+            y and z coordinates in the coordinate system of the active plane.
+        """
         raise NotImplementedError
 
     def get_local_euklid_bases(self, interpos_local):
-        '''Obtain a local eukledian base at a set of positions.
+        """Obtain a local eucledian base at a set of positions.
 
         Parameters
         ----------
         interpos_local : `numpy.ndarray` of shape (N, 2)
-            coordinates in the coordiante system of the geometry (e.g. (x, y),
+            coordinates in the coordinate system of the geometry (e.g. (x, y),
             or (r, phi)).
 
         Returns
         -------
         e_1, e_2, n : `numpy.ndarray` of shape (N, 4)
             Vectors pointing in direction 1, 2, and normal to the surface.
-        '''
+        """
         raise NotImplementedError
 
 
@@ -209,7 +209,7 @@ class FinitePlane(Geometry):
     '''name for output columns with interaction point in local coordinates.'''
 
     def intersect(self, dir, pos):
-        '''Calculate the intersection point between a ray and the element
+        """Calculate the intersection point between a ray and the element
 
         Parameters
         ----------
@@ -226,15 +226,15 @@ def intersect(self, dir, pos):
             homogeneous coordinates of the intersection point. Values are set
             to ``np.nan`` if no intersection point is found.
         interpos_local : `numpy.ndarray` of shape (N, 2)
-            y and z coordinates in the coordiante system of the active plane
+            y and z coordinates in the coordinate system of the active plane
             (not normalized to the dimensions of the element in question, but
             in absolute units).
-        '''
+        """
         k_nominator = np.dot(self['center'] - pos, self['e_x'])
         k_denom = np.dot(dir, self['e_x'])
 
         is_parallel = k_denom == 0
-        # To avoid warning for parallel rays, which is handeled expicitly below
+        # To avoid warning for parallel rays, which is handled explicitly below
         with np.errstate(divide='ignore'):
             k = k_nominator / k_denom
 
@@ -261,18 +261,18 @@ def intersect(self, dir, pos):
         return intersect, interpos, interpos_local
 
     def get_local_euklid_bases(self, interpos_local):
-        '''Obtain a local eukledian base at a set of positions.
+        """Obtain a local euclidean base at a set of positions.
 
         Parameters
         ----------
         interpos_local : `numpy.ndarray` of shape (N, 2)
-            coordinates in the coordiante system of the geometry (x, y)
+            coordinates in the coordinate system of the geometry (x, y)
 
         Returns
         -------
         e_1, e_2, n : `numpy.ndarray` of shape (N, 4)
             Vectors pointing in direction 1, 2, and normal to the surface.
-        '''
+        """
 
         n = interpos_local.shape[0]
         x = np.tile(self['e_x'], (n, 1))
@@ -282,28 +282,27 @@ def get_local_euklid_bases(self, interpos_local):
 
 
 class PlaneWithHole(FinitePlane):
-
-    shape = 'triangulation'
-    outer_factor = 3
+    shape = "triangulation"
     inner_factor = 0
+    outer_factor = 3
 
     def __init__(self, kwargs):
         self._geometry['r_inner'] = kwargs.pop('r_inner', 0.)
         super().__init__(kwargs)
 
     def triangulate(self, display={}):
-        '''Return a triangulation of the aperture hole embedded in a square.
+        """Return a triangulation of the aperture hole embedded in a square.
 
         The size of the outer square is determined by the ``'outer_factor'``
         element in ``self.display``.
 
         Returns
         -------
         xyz : np.array
-            Numpy array of vertex positions in Eukeldian space
+            Numpy array of vertex positions in Euclidean space
         triangles : np.array
             Array of index numbers that define triangles
-        '''
+        """
         outer_disp = self.outer_display(display)
         outer_shape = self.outer_shape(display)
 
@@ -320,16 +319,16 @@ def triangulate(self, display={}):
 
         return xyz, triangles
 
-    def outer_shape(self, diplay):
+    def outer_shape(self, display):
         raise NotImplementedError
 
-    def outer_display(self, diplay):
+    def outer_display(self, display):
         raise NotImplementedError
 
-    def inner_shape(self, diplay):
+    def inner_shape(self, display):
         raise NotImplementedError
 
-    def inner_display(self, diplay):
+    def inner_display(self, display):
         raise NotImplementedError
 
 
@@ -356,7 +355,7 @@ def __init__(self, kwargs):
         super().__init__(kwargs)
 
     def outer_display(self, display):
-        '''Return values in Eukledian space.'''
+        """Return values in Euclidean space."""
         return xyz_circle(self, r_factor=display['outer_factor'])
 
     def outer_shape(self, display):
@@ -374,6 +373,12 @@ def inner_display(self, display):
                           r_factor=display['inner_factor'] * self['r_inner'] / np.linalg.norm(self['v_y']),
                           philim=self.phi)
 
+    def intersect(self, dir, pos):
+        intersect, interpos, interpos_local = super().intersect(dir, pos)
+        r = np.linalg.norm(interpos_local, axis=1)
+        intersect &= r <= 1.0
+        return intersect, interpos, interpos_local
+
 
 class Cylinder(Geometry):
     '''A Geometry shaped like a ring or tube.

marxs/missions/mitsnl/catgrating.py

@@ -158,8 +158,7 @@ def __init__(self, qualityfactor=qualityfactor, **kwargs):
         super().__init__(**kwargs)
 
     def specific_process_photons(self, photons, intersect, interpos, intercoos):
-        return {'probability': self.factor**(photons['order'][intersect]**2)}
-        return photons
+        return {"probability": self.factor ** (photons["order"][intersect] ** 2)}
 
 
 def check_lx_dims(lx_dims):

marxs/optics/__init__.py

@@ -6,7 +6,7 @@
                       OrderSelector, EfficiencyFile
                       )
 from .mirror import ThinLens, PerfectLens
-from .baffles import Baffle
+from .baffles import Baffle, CircularBaffle
 from .scatter import RadialMirrorScatter, RandomGaussianScatter
 from .filter import EnergyFilter, GlobalEnergyFilter
 from .base import OpticalElement, FlatOpticalElement, FlatStack