Merge pull request #23 from simonsobs/trajectory

Trajectory

Author: skhrg

lat_alignment/adjustments.py

@@ -13,28 +13,28 @@
 
 
 def rotate(
-    point: NDArray[np.float32],
-    end_point1: NDArray[np.float32],
-    end_point2: NDArray[np.float32],
-    theta: np.float32,
-) -> NDArray[np.float32]:
+    point: NDArray[np.float64],
+    end_point1: NDArray[np.float64],
+    end_point2: NDArray[np.float64],
+    theta: np.float64,
+) -> NDArray[np.float64]:
     """
     Rotate a point about an axis
 
     Parameters
     ----------
-    point : NDArray[np.float32]
+    point : NDArray[np.float64]
         The point to rotate
-    end_point1 : NDArray[np.float32]
+    end_point1 : NDArray[np.float64]
         A point on the axis of rotation
-    end_point2 : NDArray[np.float32]
+    end_point2 : NDArray[np.float64]
         Another point on the axis of rotation
-    theta: NDArray[np.float32]
+    theta: NDArray[np.float64]
         Angle in radians to rotate by
 
     Returns
     -------
-    point : NDArray[np.float32]
+    point : NDArray[np.float64]
         The rotated point
     """
     origin = np.mean((end_point1, end_point2))
@@ -46,34 +46,34 @@ def rotate(
 
 
 def rotate_panel(
-    points: NDArray[np.float32],
-    adjustors: NDArray[np.float32],
-    thetha_0: np.float32,
-    thetha_1: np.float32,
-) -> Tuple[NDArray[np.float32], NDArray[np.float32]]:
+    points: NDArray[np.float64],
+    adjustors: NDArray[np.float64],
+    thetha_0: np.float64,
+    thetha_1: np.float64,
+) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
     """
     Rotate panel about axes created by adjustors.
 
     Parameters
     ----------
-    points : NDArray[np.float32]
+    points : NDArray[np.float64]
         Points on panel to rotate.
-    adjustors : NDArray[np.float32]
+    adjustors : NDArray[np.float64]
         Adjustor positions.
-    thetha_0 : np.float32
+    thetha_0 : np.float64
         Angle to rotate about first adjustor axis
-    thetha_1 : np.float32.
+    thetha_1 : np.float64.
         Angle to rotate about second adjustor axis
 
     Returns
     -------
-    rot_points : NDArray[np.float32]
+    rot_points : NDArray[np.float64]
         The rotated points.
-    rot_adjustors : NDArray[np.float32]
+    rot_adjustors : NDArray[np.float64]
         The rotated adjustors.
     """
-    rot_points = np.zeros(points.shape, np.float32)
-    rot_adjustors = np.zeros(adjustors.shape, np.float32)
+    rot_points = np.zeros(points.shape, np.float64)
+    rot_adjustors = np.zeros(adjustors.shape, np.float64)
 
     n_points = len(points)
     n_adjustors = len(adjustors)
@@ -90,51 +90,51 @@ def rotate_panel(
 
 
 def translate_panel(
-    points: NDArray[np.float32],
-    adjustors: NDArray[np.float32],
-    dx: np.float32,
-    dy: np.float32,
-    dz: np.float32,
-) -> Tuple[NDArray[np.float32], NDArray[np.float32]]:
+    points: NDArray[np.float64],
+    adjustors: NDArray[np.float64],
+    dx: np.float64,
+    dy: np.float64,
+    dz: np.float64,
+) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
     """
     Translate a panel.
 
     Parameters
     ----------
-    points : NDArray[np.float32]
+    points : NDArray[np.float64]
         The points on panel to translate.
-    adjustors : NDArray[np.float32]
+    adjustors : NDArray[np.float64]
         Adjustor positions.
-    dx : np.float32
+    dx : np.float64
         Translation in x.
-    dy : np.float32
+    dy : np.float64
         Translation in y.
-    dz : np.float32
+    dz : np.float64
         Translation in z.
 
     Returns
     -------
-    points : NDArray[np.float32]
+    points : NDArray[np.float64]
         The translated points.
-    adjustors : NDArray[np.float32]
+    adjustors : NDArray[np.float64]
         The translated adjustors.
     """
     translation = np.array((dx, dy, dz))
     return points + translation, adjustors + translation
 
 
 def adjustment_fit_func(
-    pars: NDArray[np.float32],
-    can_points: NDArray[np.float32],
-    points: NDArray[np.float32],
-    adjustors: NDArray[np.float32],
-) -> np.float32:
+    pars: NDArray[np.float64],
+    can_points: NDArray[np.float64],
+    points: NDArray[np.float64],
+    adjustors: NDArray[np.float64],
+) -> np.float64:
     r"""
     Function to minimize when calculating adjustments.
 
     Parameters
     ----------
-    pars : NDArray[np.float32]
+    pars : NDArray[np.float64]
         The parameters to fit for:
 
         * dx: Translation in x
@@ -143,16 +143,16 @@ def adjustment_fit_func(
         * thetha_0: Angle to rotate about first adjustor axis
         * thetha_1: Angle to rotate about second adjustor axis
         * z_t: Additional translation to tension the center point
-    can_points : NDArray[np.float32]
+    can_points : NDArray[np.float64]
         The cannonical positions of the points to align.
-    points : NDArray[np.float32]
+    points : NDArray[np.float64]
         The measured positions of the points to align.
-    adjustors : NDArray[np.float32]
+    adjustors : NDArray[np.float64]
         The measured positions of the adjustors.
 
     Returns
     -------
-    norm : np.float32
+    norm : np.float64
         The norm of $cannonical_positions - transformed_positions$.
     """
     dx, dy, dz, thetha_0, thetha_1, z_t = pars
@@ -163,43 +163,43 @@ def adjustment_fit_func(
 
 
 def calc_adjustments(
-    can_points: NDArray[np.float32],
-    points: NDArray[np.float32],
-    adjustors: NDArray[np.float32],
+    can_points: NDArray[np.float64],
+    points: NDArray[np.float64],
+    adjustors: NDArray[np.float64],
     **kwargs,
 ) -> Tuple[
-    np.float32,
-    np.float32,
-    NDArray[np.float32],
-    np.float32,
-    np.float32,
-    NDArray[np.float32],
+    np.float64,
+    np.float64,
+    NDArray[np.float64],
+    np.float64,
+    np.float64,
+    NDArray[np.float64],
 ]:
     """
     Calculate adjustments needed to align panel.
 
     Parameters
     ----------
-    can_points : NDArray[np.float32]
+    can_points : NDArray[np.float64]
         The cannonical position of the points to align.
-    points : NDArray[np.float32]
+    points : NDArray[np.float64]
         The measured positions of the points to align.
-    adjustors : NDArray[np.float32]
+    adjustors : NDArray[np.float64]
         The measured positions of the adjustors.
     **kwargs
         Arguments to be passed to `scipy.optimize.minimize`.
 
-    dx : np.float32
+    dx : np.float64
         The required translation of panel in x.
-    dy : np.float32
+    dy : np.float64
         The required translation of panel in y.
-    d_adj : NDArray[np.float32]
+    d_adj : NDArray[np.float64]
         The amount to move each adjustor.
-    dx_err : np.float32
+    dx_err : np.float64
         The error in the fit for `dx`.
-    dy_err : np.float32
+    dy_err : np.float64
         The error in the fit for `dy`.
-    d_adj_err : NDArray[np.float32]
+    d_adj_err : NDArray[np.float64]
         The error in the fit for `d_adj`.
     """
     res = opt.minimize(

lat_alignment/alignment.py

@@ -38,7 +38,7 @@ def log_alignment(alignment, logger):
 
 def adjust_panel(
     panel: mir.Panel, mnum: int, fit: bool, cfg: dict
-) -> NDArray[np.float32]:
+) -> NDArray[np.float64]:
     """
     Helper function to get the adjustments for a single panel.
 
@@ -57,12 +57,12 @@ def adjust_panel(
 
     Returns
     -------
-    adjustments : NDArray[np.float32]
+    adjustments : NDArray[np.float64]
         The adjustments to make for the panel.
         This is a 17 element array with the following structure:
         `[mnum, panel_row, panel_col, dx, dy, d_adj1, ..., d_adj5, dx_err, dy_err, d_adj1_err, ..., d_adj5_err]`.
     """
-    adjustments = np.zeros(17, np.float32)
+    adjustments = np.zeros(17, np.float64)
     adjustments[0] = mnum
     adjustments[1] = panel.row
     adjustments[2] = panel.col
@@ -245,7 +245,7 @@ def main():
         # Load data and compute the transformation to align with the model
         # We want to put all the transformations into opt_global
         elements = {}  # {element_name : full_alignment}
-        identity = (np.eye(3, dtype=np.float32), np.zeros(3, dtype=np.float32))
+        identity = (np.eye(3, dtype=np.float64), np.zeros(3, dtype=np.float64))
         try:
             meas, alignment = pg.align_photo(
                 dataset.copy(), reference, True, "primary", **cfg.get("align_photo", {})
@@ -276,7 +276,7 @@ def main():
                 )
                 full_alignment = mt.compose_transform(*common_mode_2, *full_alignment)
             full_alignment = tf.affine_basis_transform(
-                full_alignment[0], full_alignment[1], "opt_primary", "opt_global", False
+                full_alignment[0], full_alignment[1], "opt_primary", "opt_global"
             )
             log_alignment(full_alignment, logger)
         except Exception as e:
@@ -325,11 +325,7 @@ def main():
                 )
                 full_alignment = mt.compose_transform(*common_mode_2, *full_alignment)
             full_alignment = tf.affine_basis_transform(
-                full_alignment[0],
-                full_alignment[1],
-                "opt_secondary",
-                "opt_global",
-                False,
+                full_alignment[0], full_alignment[1], "opt_secondary", "opt_global"
             )
             log_alignment(full_alignment, logger)
         except Exception as e:

lat_alignment/bearing.py

@@ -33,7 +33,7 @@
 
 def partition_points(
     dataset: Dataset,
-) -> tuple[Dataset, Dataset, NDArray[np.float32], NDArray[np.float32]]:
+) -> tuple[Dataset, Dataset, NDArray[np.float64], NDArray[np.float64]]:
     """
     Split up dataset into points on the bearing reference surface and inner surface.
     Also pulls out the bearing zero points.
@@ -52,10 +52,10 @@ def partition_points(
     face_points : Dataset
         Points on face of the bearing that we use as a reference surface.
         Only includes targets, codes are removed.
-    zero_point : NDArray[np.float32]
+    zero_point : NDArray[np.float64]
         Array of size (3,) that gives the coordinates of the target we treat
         as the bearing's zero point.
-    zero_code: NDArray[np.float32]
+    zero_code: NDArray[np.float64]
         Array of size (3,) that gives the coordinates of the coded target we use
         to identify the bearing's zero point.
 
@@ -111,7 +111,7 @@ def partition_points(
 
 def cylinder_fit(
     dataset: Dataset,
-) -> tuple[Dataset, tuple[NDArray[np.float32], NDArray[np.float32]]]:
+) -> tuple[Dataset, tuple[NDArray[np.float64], NDArray[np.float64]]]:
     """
     Fit for the bearing's position by fitting a cylinder to the bearing surface.
     This acts as a correction on top of the alignment to reference points.
@@ -127,7 +127,7 @@ def cylinder_fit(
     inside_points : Dataset
         Points on the inner surface of the bearing with alignment applied.
         Only includes targets, codes are removed.
-    alignment : tuple[NDArray[np.float32], NDArray[np.float32]]
+    alignment : tuple[NDArray[np.float64], NDArray[np.float64]]
         The transformation that aligned the bearing.
         The first element is a rotation matrix and
         the second is the shift.
@@ -159,7 +159,7 @@ def cylinder_fit(
     logger.info("\t\tError on bearing axis alignment: %f", err)
 
     shift = rot.apply(shift)
-    rot = np.array(rot.as_matrix(), dtype=np.float32).T
+    rot = np.array(rot.as_matrix(), dtype=np.float64).T
     logger.debug("\t\tShift is %s mm", str(shift))
     logger.debug("\t\tRotation is %s deg", str(np.rad2deg(decompose_rotation(rot))))