nbs-bl 0.2.0__py3-none-any.whl

nbs_bl/gGrEqns.py

@@ -0,0 +1,171 @@
+import numpy as np
+import scipy.optimize as opt
+import bluesky.plan_stubs as bps
+from .printing import run_report
+
+run_report(__file__)
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+basic general equations applying to gratings and grating instruments
+assumes all angular arguments are passed as degrees
+assumes length units are in mm 
+@author: dvorak
+"""
+
+
+def getBetaDeg(en_eV, alpha_deg, k_invmm, m):
+    # calculate beta in deg
+    # en_eV: energy units of electron Volts
+    # alpha_deg: incident angle in degrees
+    # k_invmm: central line density in mm^-1
+    # m: diffraction order unitless integer
+    hc = 0.0012398  # in units of eV mm
+    lambda_mm = hc / en_eV  # wavelength in mm
+    alpha = np.radians(alpha_deg)  # alpha angle in radians
+    beta = np.arcsin((m * k_invmm * lambda_mm - np.sin(alpha)))  # beta angle in radians
+    return np.degrees(beta)
+
+
+def ruben2005eqn8m(en_eV, cff, k_invmm, m):
+    #   eqn 8, doi:10.1016/j.nima.2004.09.007, to calculate alpha from cff
+    #   generalized to include higher orders
+    #   en_eV is the energy in electron volts
+    #   cff is unitless constant of fixed focus
+    #   k_invmm is central line density in mm-1
+    #   m is the diffraction order, integer, unitless
+    #   returns alpha in degrees
+    #   works for grazing incidence, 2000 eV, 1800 mm-1, cff=2, m=+1 thru +5
+    #   works for grazing incidence, 2000 eV, 1800 mm-1, cff=0.2, m=-1 thru -5
+    aa = 1 / (cff ** 2 - 1)  ## unitless
+    hc = 0.0012398  # in units of eV mm
+    lambda_mm = hc / en_eV  ## in mm
+    return np.degrees(np.arcsin(-m * k_invmm * lambda_mm * aa + np.sqrt(1 + (cff * m * k_invmm * lambda_mm * aa) ** 2)))
+
+
+def get_mirror_grating_angles(en_eV, cff, k_invmm, m):
+    a = ruben2005eqn8m(en_eV, cff, k_invmm, m)  # twice the angle between mirror and grating in equation land
+    b = getBetaDeg(en_eV, a, k_invmm, m)  # angle of pre-mirror (in degrees) in equation land
+    mirror_angle = -(180 - a + b) / 2  # tangle of the mirror pitch for the actual motor (degrees)
+    grating_angle = -90 - b  # angle of the grating pitch for the actual motor (degrees)
+    return [mirror_angle, grating_angle]
+
+
+def energy(mirror,grating, k_invmm, m):
+    hc = 0.0012398  # in units of eV mm
+    b = np.radians(-90 - grating)
+    a = np.radians(2 * mirror + 90 - grating)
+    return hc * k_invmm * m / (np.sin(a) + np.sin(b))
+
+
+def find_best_offsets(mirror_pitches, grating_pitches, mguesses, eVs, k_invmm):
+    '''
+    given a bunch of measurements of mirror and grating pitches, fits the most likely constant offsets
+    for the mirror and grating pitch.  Each measurement can be at a different order(m) and a different energy
+    the grating parameters should not change, so only the constant line density is needed
+
+    mirror_pitches : list or array of length n
+        experimental mirror pitch angles
+
+    grating_pitches : list or array of length n
+        experimental grating pitch angles
+
+    m_guesses : list or array of length n
+        the diffraction order which was scanned
+
+    eVs : list or array of length n
+        the energy of each measurement (allows for different calibrants)
+
+    k_invmm : single number the central spacing of the grating in mm^-1
+
+    output: the result of numpy.optimize = has a lot of components which might be useful, the most obvious of which are
+        output.x the optimized offsets of the mirror, and grating pitch
+        output.success wether the optimize function thinks that it succeeded or not.  experince shows that good fits are still possible when this is false
+    '''
+    fit_result = opt.minimize(diffraction_pitch_offset_error_func,
+                              x0=[0.0001, -0.0001],
+                              args=(
+                                  mirror_pitches,
+                                  grating_pitches,
+                                  mguesses,
+                                  eVs,
+                                  k_invmm
+                              )
+                              )
+    return fit_result
+
+
+
+def diffraction_pitch_offset_error_func(
+        fit_elements,
+        mirror_pitches,
+        grating_pitches,
+        m_guesses,
+        en_eVs,
+        k_invmm):
+    '''
+    fit_elements, an 2 element array:
+        mirror angle offset,
+        grating angle offset
+
+    mirror_pitches : list or array of length n
+        experimental mirror pitch angles
+
+    grating_pitches : list or array of length n
+        experimental grating pitch angles
+
+    m_guesses : list or array of length n
+        the diffraction order which was scanned
+
+    en_eV : list or array of length n
+        the energy of each measurement (allows for different calibrants)
+
+    k_invmm : single number the central spacing of the grating in mm^-1
+    '''
+    error = 0
+    for mp, gp, m, en_eV in zip(mirror_pitches, grating_pitches, m_guesses, en_eVs):
+        mir = mp - fit_elements[0]  # the test mirror position
+        grat = gp - fit_elements[1]  # the test grating position
+        en_theoretical = energy(mir,grat, k_invmm, m)  # what energy these test positions would produce
+        error += (en_theoretical - en_eV) ** 2
+    return error
+# for the RSoXS grating:
+# RE(tune_pgm(cs=[1.35,1.4,1.45,1.5,1.55],ms=[1,1,1,1,1],energy=291.65,pol=90,k=250))
+
+
+def set_pgm_offsets(error_object, energy_object):
+    yield from bps.mvr(energy_object.monoen.mirror2.user_offset,-error_object.x[0]) # right now we have to set the negative of the fit value as the delta in the offset
+    yield from bps.mvr(energy_object.monoen.grating.user_offset,-error_object.x[1])
+
+
+def test_grating_fit(numpoints, minc, maxc, minm, maxm, energy, k, noise, moffset, goffset):
+    # create some fake measurements of grating and mirror positions to test the fit function
+
+    cs = np.linspace(minc, maxc, numpoints)  # used to generate test pairs of pitches
+    ms = np.round(np.linspace(minm, maxm, numpoints))
+    evs = np.ones(numpoints) * energy
+    merr = np.random.normal(0, noise, numpoints)
+    gerr = np.random.normal(0, noise, numpoints)
+
+    mirrors, gratings = list(zip(*[get_mirror_grating_angles(energy, c, k, m) for c, m in zip(cs, ms)]))
+    mirrors += merr + moffset
+    gratings += gerr + goffset
+    return find_best_offsets(mirrors, gratings, ms, evs, k)
+
+
+
+
+'''
+mirror positions: [-3.6558274763042604, -3.3921585294849734, -3.1876054822737245, -3.0234213066329048, -2.8882065368134207, -2.774584471608641, -2.6775464182938222, -2.5935586706589646]
+grating positions: [-4.107032615400001, -3.880574386500001, -3.709388039800004, -3.5753463783000043, -3.4671052284000012, -3.379157631200002, -3.3047008284000015, -3.242455403500003]
+energy positions: [291.65, 291.65, 291.65, 291.65, 291.65, 291.65, 291.65, 291.65]
+orders: [1, 1, 1, 1, 1, 1, 1, 1]
+
+
+mirror positions: [-3.234388850111962, -3.0810948898872326, -2.9527235798924423, -4.572999932948626, -4.3563799893796045, -4.1749665476012225]                                             
+grating positions: [-3.7760457088000052, -3.6498169308000072, -3.546186037900007, -5.3394722246000015, -5.160893796100005, -5.014527626700001]
+energy positions: [291.65, 291.65, 291.65, 291.65, 291.65, 291.65]
+orders: [1, 1, 1, 2, 2, 2]
+
+'''

nbs_bl/geometry/affine.py

@@ -0,0 +1,197 @@
+import numpy as np
+
+
+class NullFrame:
+    def __init__(self, dim):
+        self.dim = dim
+        self.origin = np.zeros(dim)
+
+    def get_global(self):
+        return self
+
+    def to_global(self, coords):
+        return coords
+
+    def from_global(self, coords):
+        return coords
+
+    def make_child_frame(self, *axes, origin=None):
+        return Frame(*axes, origin=origin, parent=self)
+
+
+class Frame:
+    def __init__(self, *axes, origin=None, parent=None):
+        if not axes and origin is None:
+            raise ValueError("Either axes or origin must be provided")
+
+        if origin is not None:
+            self.origin = np.array(origin)
+            self.dim = len(origin)
+
+            if not axes:
+                axes = [
+                    tuple([1 if i == j else 0 for i in range(self.dim)])
+                    for j in range(self.dim)
+                ]
+
+            self.axes = tuple(self._ensure_axis(ax) for ax in axes)
+        else:
+            self.axes = tuple(self._ensure_axis(ax) for ax in axes)
+            self.dim = self.axes[0].dim
+            self.origin = np.zeros(self.dim)
+
+        if parent is not None:
+            self.parent = parent
+            if self.parent.dim != self.dim:
+                raise ValueError("Frame must have same dimension as parent")
+        else:
+            self.parent = NullFrame(self.dim)
+
+        if len(self.origin) != self.dim:
+            raise ValueError("Origin must have same dimension as axes")
+
+        if any(axis.dim != self.dim for axis in self.axes):
+            raise ValueError("All axes must have the same dimension")
+
+        if len(self.axes) != self.dim:
+            raise ValueError("Number of axes must equal the dimension of each axis")
+
+        self.A = np.column_stack(
+            [axis.coords for axis in self.axes] + [np.append(self.origin, 1)]
+        )
+        self.Ainv = np.linalg.inv(self.A)
+
+    @staticmethod
+    def _ensure_axis(ax):
+        """
+        Convert coordinate tuple to Axis object if necessary.
+
+        Parameters
+        ----------
+        ax : Axis or tuple
+            The axis or coordinates to convert.
+
+        Returns
+        -------
+        Axis
+            An Axis object.
+        """
+        if isinstance(ax, Axis):
+            return ax
+        elif isinstance(ax, (tuple, list, np.ndarray)):
+            return Axis.from_coords(*ax)
+        else:
+            raise ValueError(
+                f"Invalid axis type: {type(ax)}. Expected Axis or coordinate tuple."
+            )
+
+    def get_global(self):
+        return self.parent.get_global()
+
+    def to_parent(self, coords):
+        if len(coords) != self.dim:
+            raise ValueError("Coordinates must have same Dimension as Frame")
+        return np.dot(self.A, np.append(coords, 1))[:-1]
+
+    def to_global(self, coords):
+        if len(coords) != self.dim:
+            raise ValueError("Coordinates must have same Dimension as Frame")
+        return self.parent.to_global(self.to_parent(coords))
+
+    def to_frame(self, coords, frame):
+        if self.get_global() != frame.get_global():
+            raise ValueError("Frames must have same global frame")
+        global_coords = self.to_global(coords)
+        return frame.from_global(global_coords)
+
+    def from_parent(self, coords):
+        """
+        coords in parent frame
+        """
+        return np.dot(self.Ainv, np.append(coords, 1))[:-1]
+
+    def from_global(self, coords):
+        """
+        coords in parent frame
+        """
+        parent_coords = self.parent.from_global(coords)
+        return self.from_parent(parent_coords)
+
+    def make_child_frame(self, *axes, origin=None):
+        return Frame(*axes, origin=origin, parent=self)
+
+    def rotate_in_plane(self, coords, phi, ax1=0, ax2=1):
+        """
+        Rotates around z-axis by default
+        """
+        M = np.zeros((self.dim, self.dim))
+        for i in range(self.dim):
+            if i != ax1 and i != ax2:
+                M[i, i] = 1
+        M[ax1, ax1] = np.cos(phi)
+        M[ax1, ax2] = -np.sin(phi)
+        M[ax2, ax1] = np.sin(phi)
+        M[ax2, ax2] = np.cos(phi)
+        return np.dot(M, np.array(coords))
+
+
+class Axis:
+    def __init__(self, *coords):
+        self.coords = np.array(coords + (0,))
+        self.dim = len(coords)
+
+    @classmethod
+    def from_coords(cls, *coords):
+        """
+        Create an Axis object from a list of coordinates, normalizing them.
+
+        Parameters
+        ----------
+        coords : list or array-like
+            The coordinates to create the Axis from.
+
+        Returns
+        -------
+        Axis
+            A new Axis object with normalized coordinates.
+
+        """
+        coords = np.array(coords)
+        norm = np.linalg.norm(coords)
+        if norm == 0:
+            raise ValueError("Cannot create an Axis with zero-length vector")
+        normalized_coords = coords / norm
+        return cls(*normalized_coords)
+
+
+def angle_between_vectors_2d(v1, v2):
+    """
+    Calculate the angle between two 2D vectors in the x-y plane.
+
+    Parameters:
+    v1, v2 : array-like
+        The two vectors to compare. Each should be a 2D vector [x, y].
+
+    Returns:
+    float
+        The angle between the vectors in radians.
+    """
+    # Ensure the vectors are numpy arrays
+    v1 = np.array(v1)
+    v2 = np.array(v2)
+
+    # Calculate the angle using atan2
+    angle = np.arctan2(v2[1], v2[0]) - np.arctan2(v1[1], v1[0])
+
+    # Normalize the angle to be between -pi and pi
+    return angle % (2 * np.pi)
+
+
+def find_rotation(child_frame, child_ax, parent_frame, parent_ax, around_ax=2):
+    origin = child_frame.to_frame([0, 0, 0], parent_frame)
+    vector = child_frame.to_frame(child_ax, parent_frame) - origin
+
+    angle = angle_between_vectors_2d(
+        np.delete(vector, around_ax), np.delete(parent_ax, around_ax)
+    )
+    return angle

nbs_bl/geometry/bars.py

@@ -0,0 +1,189 @@
+from abc import ABC, abstractmethod
+import csv
+
+
+class GeometryBase(ABC):
+    @abstractmethod
+    def make_sample_frame(self, position):
+        """
+        Create a sample frame for the given position.
+
+        Parameters
+        ----------
+        position : Any
+            The position for which to create a sample frame.
+
+        Returns
+        -------
+        Frame
+            The created sample frame.
+        """
+        pass
+
+    @abstractmethod
+    def generate_geometry(self):
+        """
+        Generate the geometry for the holder.
+        """
+        pass
+
+    @abstractmethod
+    def get_geometry(self):
+        """
+        Get the geometry of the holder.
+
+        Returns
+        -------
+        Any
+            The geometry of the holder.
+        """
+        pass
+
+    def attach_manipulator(self, manipframe):
+        self.manip_frame = manipframe
+        self.generate_geometry()
+
+    def read_sample_file(self, filename):
+        extension = filename.split(".")[-1]
+        if extension in ["csv"] and hasattr(self, "read_sample_csv"):
+            return self.read_sample_csv(filename)
+        else:
+            raise AttributeError(
+                f"File had extension {extension}, but this geometry has no read method"
+            )
+
+
+class AbsoluteBar(GeometryBase):
+    """
+    This is a geometry that assumes that the position is absolute, and will never attempt
+    to do any coordinate transformations.
+    """
+
+    def __init__(self):
+        pass
+
+    def make_sample_frame(self, position):
+        """
+        Always assume that the position is absolute, and return the coordinates
+        """
+        return position
+
+    def generate_geometry(self):
+        pass
+
+    def get_geometry(self):
+        side_md = {}
+        side_frames = {}
+        return side_md, side_frames
+
+
+class Standard4SidedBar(GeometryBase):
+    def __init__(self, width, length):
+        self.length = length
+        self.sides = 4
+        self.width = width
+
+    def make_sample_frame(self, position):
+        side = position.get("side")
+        # origin = position.get("origin", "bar")
+        # if origin in ["abs", "absolute"]:
+        #     x, y, z, r = position.get("coordinates")
+        #     origin = (x, y, z)
+        #     parent_frame = self.manip_frame.parent
+        #     sample_frame = parent_frame.make_child_frame(origin=origin)
+
+        # else:
+        x1, y1, x2, y2 = position.get("coordinates")
+        z = position.get("thickness", 0)
+        origin = (0.5 * (x1 + x2), 0.5 * (y1 + y2), z)
+        parent_frame = self.side_frames[int(side) - 1]
+        sample_frame = parent_frame.make_child_frame(origin=origin)
+        return sample_frame
+
+    def generate_geometry(self):
+        """Very brute force, could be refined to be more general"""
+        axes = [(1, 0, 0), (0, 0, 1), (0, -1, 0)]
+        origin = (0, 0, -1 * self.length)
+        self.bar_frame = self.manip_frame.make_child_frame(*axes, origin=origin)
+        side_axes = [
+            [(0, 0, 1), (0, 1, 0), (-1, 0, 0)],
+            [(-1, 0, 0), (0, 1, 0), (0, 0, -1)],
+            [(0, 0, -1), (0, 1, 0), (1, 0, 0)],
+            [(1, 0, 0), (0, 1, 0), (0, 0, 1)],
+        ]
+        hw = self.width / 2.0
+        side_origins = [(-hw, 0, -hw), (hw, 0, -hw), (hw, 0, hw), (-hw, 0, hw)]
+        self.side_frames = [
+            self.bar_frame.make_child_frame(*axes, origin=origin)
+            for axes, origin in zip(side_axes, side_origins)
+        ]
+
+    def get_geometry(self):
+        # Implement the method here
+        side_md = {}
+        side_frames = {}
+        for n in range(self.sides):
+            side_frame = self.side_frames[n]
+            side_str = f"side{n+1}"  # Humans one-index sides...
+            side_dict = {
+                "name": side_str,
+                "id": side_str,
+                "description": side_str,
+                "position": [],
+            }
+            side_md[side_str] = side_dict
+            side_frames[side_str] = side_frame
+        return side_md, side_frames
+
+    def read_sample_csv(self, filename):
+        with open(filename, "r") as f:
+            sampleReader = csv.reader(f, skipinitialspace=True)
+            samplelist = [row for row in sampleReader]
+            rownames = [n for n in samplelist[0] if n != ""]
+            # rownames = ["sample_id", "sample_name", "side", "x1", "y1", "x2", "y2",
+            #            "t", "tags"]
+            samples = {}
+            for sample in samplelist[1:]:
+                sample_id = sample[0]
+                sample_dict = {
+                    key: sample[rownames.index(key)]
+                    for key in rownames[1:]
+                    if sample[rownames.index(key)] != ""
+                }
+                coordinates = (
+                    float(sample_dict.pop("x1")),
+                    float(sample_dict.pop("y1")),
+                    float(sample_dict.pop("x2")),
+                    float(sample_dict.pop("y2")),
+                )
+                thickness = sample_dict.pop("thickness", 0)
+                side = sample_dict.pop("side")
+                position = {
+                    "side": side,
+                    "coordinates": coordinates,
+                    "thickness": thickness,
+                }
+                sample_dict["position"] = position
+                samples[sample_id] = sample_dict
+                if "sample_name" in sample_dict:
+                    name = sample_dict.pop("sample_name")
+                    sample_dict["name"] = name
+        return samples
+
+
+class Bar1d(GeometryBase):
+    def __init__(self):
+        pass
+
+    def generate_geometry(self):
+        pass
+
+    def get_geometry(self):
+        side_md = {}
+        side_frames = {}
+        return side_md, side_frames
+
+    def make_sample_frame(self, position):
+        x = position.get("coordinates")
+        child_frame = self.manip_frame.make_child_frame(origin=x)
+        return child_frame