Formatting

Author: JBorrow

mapcat/database/pointing_residual.py

@@ -13,6 +13,7 @@
 
 PointingModel = ConstantPointingModel | PolynomialPointingModel
 
+
 class PointingResidualTable(SQLModel, table=True):
     """
     Table for tracking Pointing error for a depth one map,
@@ -38,8 +39,8 @@ class PointingResidualTable(SQLModel, table=True):
         foreign_key="depth_one_maps.map_id",
         ondelete="CASCADE",
     )
-    residual_model: PointingModel = Field(sa_type=JSONEncodedPydantic(PointingModel)
-    )
-    residual_stats: PointingModelStats | None = Field(nullable=True, default=None, sa_type=JSONEncodedPydantic(PointingModelStats)
+    residual_model: PointingModel = Field(sa_type=JSONEncodedPydantic(PointingModel))
+    residual_stats: PointingModelStats | None = Field(
+        nullable=True, default=None, sa_type=JSONEncodedPydantic(PointingModelStats)
     )
     map: DepthOneMapTable = Relationship(back_populates="pointing_residual")

mapcat/pointing/poly.py

@@ -26,13 +26,13 @@ class PolynomialCoefficients(BaseModel):
             }
     labels = {'x':'ra', 'y':'dec'}
     """
-    coeffs: dict[str,float]
+
+    coeffs: dict[str, float]
     labels: dict[str, str]
     unit: AstroPydanticUnit = u.deg
     poly_order: int
 
 
-
 class PolynomialPointingModel(PointingModelProtocol):
     model_type: Literal["polynomial"] = "polynomial"
 
@@ -55,22 +55,23 @@ def _poly_keys(self):
                 keys.append(f"x^{i}y^{j}")
         return keys
 
-    def build_model(self, 
-                        measured_positions: SkyCoord, 
-                        expected_positions: SkyCoord, 
-                        weights: tuple[list[float], list[float]] | list[float] | None = None
-                        ):
+    def build_model(
+        self,
+        measured_positions: SkyCoord,
+        expected_positions: SkyCoord,
+        weights: tuple[list[float], list[float]] | list[float] | None = None,
+    ):
         """
         Calculate and set the polynomial coefficients for the pointing model
         using the measured and expected positions.
 
-        weights can be provided as a tuple of (ra_weights, dec_weights) 
+        weights can be provided as a tuple of (ra_weights, dec_weights)
         or a single list that applies to both.
-        
+
 
         Raises
         ------
-        ValueError 
+        ValueError
             If no positions are provided for model calculation.
         ValueError
             If the lengths of weights do not match the number of positions.
@@ -83,7 +84,7 @@ def build_model(self,
         n = len(ra_offsets)
         if n == 0:
             raise ValueError("No positions provided for model calculation.")
-        
+
         # Unpack weights into ra_weights, dec_weights
         if isinstance(weights, tuple):
             ra_weights, dec_weights = weights
@@ -102,8 +103,12 @@ def build_model(self,
 
         ra_weights = np.asarray(ra_weights)
         dec_weights = np.asarray(dec_weights)
-        assert len(ra_weights) == n, "Length of ra_weights must match number of positions"
-        assert len(dec_weights) == n, "Length of dec_weights must match number of positions"
+        assert len(ra_weights) == n, (
+            "Length of ra_weights must match number of positions"
+        )
+        assert len(dec_weights) == n, (
+            "Length of dec_weights must match number of positions"
+        )
 
         ras = measured_positions.ra.to_value(u.deg)
         decs = measured_positions.dec.to_value(u.deg)
@@ -125,25 +130,34 @@ def build_model(self,
         Aw = A_dec * w_dec[:, None]
         yw = y_dec * w_dec
         coeffs_dec, *_ = np.linalg.lstsq(Aw, yw, rcond=None)
-        
-        ra_coeff_dict = {key: coeff for key, coeff in zip(self._poly_keys(), coeffs_ra)}
-        dec_coeff_dict = {key: coeff for key, coeff in zip(self._poly_keys(), coeffs_dec)}
-
-        self.ra_model_coefficients=PolynomialCoefficients(coeffs=ra_coeff_dict, labels={'x':'ra', 'y':'dec'}, unit=u.deg, poly_order=self.poly_order)
-        self.dec_model_coefficients=PolynomialCoefficients(coeffs=dec_coeff_dict, labels={'x':'ra', 'y':'dec'}, unit=u.deg, poly_order=self.poly_order)
-        
 
-    def model_fn(
-        self, x: u.Quantity, y: u.Quantity, coeffs: np.ndarray
-    ) -> u.Quantity:
+        ra_coeff_dict = {key: coeff for key, coeff in zip(self._poly_keys(), coeffs_ra)}
+        dec_coeff_dict = {
+            key: coeff for key, coeff in zip(self._poly_keys(), coeffs_dec)
+        }
+
+        self.ra_model_coefficients = PolynomialCoefficients(
+            coeffs=ra_coeff_dict,
+            labels={"x": "ra", "y": "dec"},
+            unit=u.deg,
+            poly_order=self.poly_order,
+        )
+        self.dec_model_coefficients = PolynomialCoefficients(
+            coeffs=dec_coeff_dict,
+            labels={"x": "ra", "y": "dec"},
+            unit=u.deg,
+            poly_order=self.poly_order,
+        )
+
+    def model_fn(self, x: u.Quantity, y: u.Quantity, coeffs: np.ndarray) -> u.Quantity:
         x = np.atleast_1d(x.to_value(u.deg))
         y = np.atleast_1d(y.to_value(u.deg))
         T = self._poly_terms(x, y)
         return (T @ coeffs) * u.deg
-    
+
     def extract_coefficients(self) -> tuple[np.ndarray, np.ndarray]:
         """
-        Extract the coefficients from the PolynomialCoefficients dataclasss and 
+        Extract the coefficients from the PolynomialCoefficients dataclasss and
         return them as arrays in the correct order for the model function.
 
         Raises
@@ -153,26 +167,26 @@ def extract_coefficients(self) -> tuple[np.ndarray, np.ndarray]:
         """
         if self.ra_model_coefficients is None or self.dec_model_coefficients is None:
             raise ValueError("Model coefficients have not been calculated yet.")
-        
+
         ra_coeff_array = np.zeros(len(self.ra_model_coefficients.coeffs))
         for i, key in enumerate(self._poly_keys()):
             ra_coeff_array[i] = self.ra_model_coefficients.coeffs.get(key, 0)
-        
+
         dec_coeff_array = np.zeros(len(self.dec_model_coefficients.coeffs))
         for i, key in enumerate(self._poly_keys()):
             dec_coeff_array[i] = self.dec_model_coefficients.coeffs.get(key, 0)
-        
+
         return ra_coeff_array, dec_coeff_array
-    
+
     def predict(self, pos: SkyCoord) -> SkyCoord:
-        racoeffs,deccoeffs = self.extract_coefficients()
+        racoeffs, deccoeffs = self.extract_coefficients()
         ra_offset = self.model_fn(pos.ra, pos.dec, racoeffs)
         dec_offset = self.model_fn(pos.ra, pos.dec, deccoeffs)
         ra = pos.ra - ra_offset
         dec = pos.dec - dec_offset
 
         return SkyCoord(ra=ra, dec=dec, frame=pos.frame)
-    
+
     def calculate_statistics(self, positions: SkyCoord):
         new_positions = self.predict(positions)
         ra_residuals = (new_positions.ra - positions.ra).to(u.arcsec)
@@ -186,4 +200,4 @@ def calculate_statistics(self, positions: SkyCoord):
             mean_dec_offset=mean_dec,
             stddev_ra_offset=std_ra,
             stddev_dec_offset=std_dec,
-        )
+        )

tests/test_pointing.py

@@ -55,8 +55,7 @@ def test_make_constant_pointing_model():
     assert model.ra_offset == 0.5 * u.deg
     assert model.dec_offset == 0.5 * u.deg
 
-    og_pos = SkyCoord(ra=10 * u.deg, dec=20 * u.deg
-                      )
+    og_pos = SkyCoord(ra=10 * u.deg, dec=20 * u.deg)
     offset_pos = SkyCoord(og_pos.ra + model.ra_offset, og_pos.dec + model.dec_offset)
     new_pos = model.predict(offset_pos)
     assert new_pos.ra == og_pos.ra
@@ -71,18 +70,32 @@ def test_make_polynomial_pointing_model():
     slope = 0.1 * u.arcmin / u.deg
 
     offset_positions = SkyCoord(
-            ra=ras + offset + slope * ras, dec=decs + offset + slope * decs
-        )
-    model.build_model(measured_positions=offset_positions, expected_positions=SkyCoord(ras, decs))
+        ra=ras + offset + slope * ras, dec=decs + offset + slope * decs
+    )
+    model.build_model(
+        measured_positions=offset_positions, expected_positions=SkyCoord(ras, decs)
+    )
 
     assert model.ra_model_coefficients is not None
     assert model.dec_model_coefficients is not None
 
     for i, offset_pos in enumerate(offset_positions):
         predicted_pos = model.predict(offset_pos)
-        assert np.isclose(predicted_pos.ra.to_value(u.arcmin), ras[i].to_value(u.arcmin), atol=0.1)
-        assert np.isclose(predicted_pos.dec.to_value(u.arcmin), decs[i].to_value(u.arcmin), atol=0.1)
+        assert np.isclose(
+            predicted_pos.ra.to_value(u.arcmin), ras[i].to_value(u.arcmin), atol=0.1
+        )
+        assert np.isclose(
+            predicted_pos.dec.to_value(u.arcmin), decs[i].to_value(u.arcmin), atol=0.1
+        )
 
     predicted_pos = model.predict(offset_positions)
-    assert np.all(np.isclose(predicted_pos.ra.to_value(u.arcmin), ras.to_value(u.arcmin), atol=0.1))
-    assert np.all(np.isclose(predicted_pos.dec.to_value(u.arcmin), decs.to_value(u.arcmin), atol=0.1))
+    assert np.all(
+        np.isclose(
+            predicted_pos.ra.to_value(u.arcmin), ras.to_value(u.arcmin), atol=0.1
+        )
+    )
+    assert np.all(
+        np.isclose(
+            predicted_pos.dec.to_value(u.arcmin), decs.to_value(u.arcmin), atol=0.1
+        )
+    )