asteroid_spinprops 1.1.1__tar.gz → 1.2.0__tar.gz

{asteroid_spinprops-1.1.1 → asteroid_spinprops-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asteroid_spinprops
-Version: 1.1.1
+Version: 1.2.0
 Summary: Collection of tools used for fitting sHG1G2 and SOCCA photometric models to sparse asteroid photometry
 License: MIT
 Author: Odysseas

{asteroid_spinprops-1.1.1 → asteroid_spinprops-1.2.0}/asteroid_spinprops/ssolib/modelfit.py

@@ -2,23 +2,27 @@ import numpy as np
 import pandas as pd
 
 import asteroid_spinprops.ssolib.utils as utils
+import asteroid_spinprops.ssolib.periodest as periodest
 
 from fink_utils.sso.spins import (
     estimate_sso_params,
     func_hg1g2_with_spin,
 )
-from asteroid_spinprops.ssolib.periodest import get_period_estimate, get_multiterm_period_estimate, perform_residual_resampling
+from asteroid_spinprops.ssolib.periodest import (
+    get_multiterm_period_estimate,
+)
 
 
 def get_fit_params(
     data,
     flavor,
     shg1g2_constrained=True,
-    blind_scan=True,
+    period_blind=True,
+    pole_blind=True,
     p0=None,
-    survey_filter=None,
     alt_spin=False,
     period_in=None,
+    period_quality_flag=False,
     terminator=False,
 ):
     """
@@ -44,12 +48,12 @@ def get_fit_params(
         Model type to fit. Must be 'SHG1G2' or 'SOCCA'.
     shg1g2_constrained : bool, optional
         Whether to constrain the SOCCA fit using a prior SHG1G2 solution. Default True.
-    blind_scan : bool, optional
-        If True, perform a small grid search over initial pole positions and periods. Default True.
+    period_blind : bool, optional
+        If True, perform a small grid search over initial periods. Default True.
+    pole_blind : bool, optional
+        If True, perform a grid search over initial poles. Default True.
     p0 : list, optional
         Initial guess parameters for the fit. Required if `shg1g2_constrained=False`.
-    survey_filter : str or None, optional
-        If 'ZTF' or 'ATLAS', only data from that survey are used. Default None uses all data.
     alt_spin : bool, optional
         For SOCCA constrained fits, use the antipodal spin solution. Default False.
     period_in : float, optional
@@ -80,36 +84,26 @@ def get_fit_params(
         If `flavor` is not 'SHG1G2' or 'SOCCA'.
     """
 
-    if survey_filter is None:
-        filter_mask = np.array(data["cfid"].values[0]) >= 0
-    if survey_filter == "ZTF":
-        filter_mask = (np.array(data["cfid"].values[0]) == 1) | (
-            np.array(data["cfid"].values[0]) == 2
-        )
-    if survey_filter == "ATLAS":
-        filter_mask = (np.array(data["cfid"].values[0]) == 3) | (
-            np.array(data["cfid"].values[0]) == 4
-        )
     if flavor == "SHG1G2":
         if p0 is None:
             Afit = estimate_sso_params(
-                magpsf_red=data["cmred"].values[0][filter_mask],
-                sigmapsf=data["csigmapsf"].values[0][filter_mask],
-                phase=np.radians(data["Phase"].values[0][filter_mask]),
-                filters=data["cfid"].values[0][filter_mask],
-                ra=np.radians(data["ra"].values[0][filter_mask]),
-                dec=np.radians(data["dec"].values[0][filter_mask]),
+                magpsf_red=data["cmred"].values[0],
+                sigmapsf=data["csigmapsf"].values[0],
+                phase=np.radians(data["Phase"].values[0]),
+                filters=data["cfid"].values[0],
+                ra=np.radians(data["ra"].values[0]),
+                dec=np.radians(data["dec"].values[0]),
                 model="SHG1G2",
             )
 
         if p0 is not None:
             Afit = estimate_sso_params(
-                magpsf_red=data["cmred"].values[0][filter_mask],
-                sigmapsf=data["csigmapsf"].values[0][filter_mask],
-                phase=np.radians(data["Phase"].values[0][filter_mask]),
-                filters=data["cfid"].values[0][filter_mask],
-                ra=np.radians(data["ra"].values[0][filter_mask]),
-                dec=np.radians(data["dec"].values[0][filter_mask]),
+                magpsf_red=data["cmred"].values[0],
+                sigmapsf=data["csigmapsf"].values[0],
+                phase=np.radians(data["Phase"].values[0]),
+                filters=data["cfid"].values[0],
+                ra=np.radians(data["ra"].values[0]),
+                dec=np.radians(data["dec"].values[0]),
                 model="SHG1G2",
                 p0=p0,
             )
@@ -118,11 +112,15 @@ def get_fit_params(
     if flavor == "SOCCA":
         if shg1g2_constrained is True:
             shg1g2_params = get_fit_params(
-                data=data, flavor="SHG1G2", survey_filter=survey_filter
-            )
-            residuals_dataframe = make_residuals_df(
-                data, model_parameters=shg1g2_params
+                data=data, flavor="SHG1G2"
             )
+            try:
+                residuals_dataframe = make_residuals_df(
+                    data, model_parameters=shg1g2_params
+                )
+            except Exception:
+                SOCCA_opt = {"Failed at period search preliminary steps": 3}
+                return SOCCA_opt
             if period_in is None:
                 # Period search boundaries (in days)
                 pmin, pmax = 5e-2, 1e4
@@ -132,20 +130,31 @@ def get_fit_params(
                             residuals_dataframe, p_min=pmin, p_max=pmax, k_free=True
                         )
                     )
+                    if period_quality_flag:
+                        _, Nbs = periodest.perform_residual_resampling(
+                            resid_df=residuals_dataframe, p_min=pmin, p_max=pmax, k=int(k_val)
+                            )
                 except KeyError:
                     # If more than 10 terms are required switch to fast rotator:
                     pmin, pmax = 5e-3, 5e-2
-
-                    p_in, k_val, p_rms, signal_peaks, window_peaks = (
-                        get_multiterm_period_estimate(
-                            residuals_dataframe, p_min=pmin, p_max=pmax, k_free=True
+                    try:
+                        p_in, k_val, p_rms, signal_peaks, window_peaks = (
+                            get_multiterm_period_estimate(
+                                residuals_dataframe, p_min=pmin, p_max=pmax, k_free=True
+                            )
                         )
-                    )
+                        if period_quality_flag:
+                            _, Nbs = periodest.perform_residual_resampling(
+                                resid_df=residuals_dataframe, p_min=pmin, p_max=pmax, k=int(k_val)
+                                )
+                    except Exception:
+                        SOCCA_opt = {"Failed at period search after": 4}
+                        return SOCCA_opt
                 period_sy = p_in
             else:
                 period_sy = period_in
 
-            if blind_scan is True:
+            if period_blind is True:
                 rms = []
                 model = []
 
@@ -155,9 +164,54 @@ def get_fit_params(
 
                 ra0, dec0 = shg1g2_params["alpha0"], shg1g2_params["delta0"]
 
-                ra_init, dec_init = utils.generate_initial_points(
-                    ra0, dec0, dec_shift=45
-                )
+                if pole_blind is True:
+                    ra_init, dec_init = utils.generate_initial_points(
+                        ra0, dec0, dec_shift=45
+                    )
+
+                else:
+                    rarange = np.arange(0, 360, 10)
+                    decrange = np.arange(-90, 90, 5)
+                    rms_landscape = np.ones(shape=(len(rarange), len(decrange)))
+
+                    for i, ra0 in enumerate(rarange):
+                        for j, dec0 in enumerate(decrange):
+
+                            all_residuals = []
+
+                            for ff in np.unique(data["cfid"].values[0]):
+                                cond_ff  = data["cfid"].values[0] == ff
+
+                                pha = [np.radians(data["Phase"].values[0][cond_ff]),
+                                    np.radians(data["ra"].values[0][cond_ff]),
+                                    np.radians(data["dec"].values[0][cond_ff])]
+
+                                H  = shg1g2_params[f"H_{ff}"]
+                                G1 = shg1g2_params[f"G1_{ff}"]
+                                G2 = shg1g2_params[f"G2_{ff}"]
+                                R  = shg1g2_params["R"]
+
+                                C = func_hg1g2_with_spin(pha, H, G1, G2, R,
+                                                        np.radians(ra0), np.radians(dec0))
+
+                                O = data["cmred"].values[0][cond_ff]
+
+                                all_residuals.append(O - C)
+
+                            all_residuals = np.concatenate(all_residuals)
+                            rms_landscape[j, i] = np.sqrt(np.mean(all_residuals**2))
+
+                    interp_vals = utils.gaussian_interpolate(rms_landscape, factor=4, sigma=1.0)
+                    ny, nx = interp_vals.shape
+                    [rarange[0], rarange[-1], decrange[0], decrange[-1]]
+                    ra_vals  = np.linspace(rarange.min(),  rarange.max(),  nx)
+                    dec_vals = np.linspace(decrange.min(), decrange.max(), ny)
+                    ys, xs = utils.detect_local_minima(interp_vals)
+                    ra_minima  = ra_vals[xs]
+                    dec_minima = dec_vals[ys]
+
+                    ra_init = ra_minima
+                    dec_init = dec_minima
 
                 H_key = next(
                     (f"H_{i}" for i in range(1, 7) if f"H_{i}" in shg1g2_params),
@@ -190,9 +244,26 @@ def get_fit_params(
                             model.append(SOCCA)
                         except Exception:
                             continue
-                rms = np.array(rms)
-                SOCCA_opt = model[rms.argmin()]
-
+                try:
+                    rms = np.array(rms)
+                    SOCCA_opt = model[rms.argmin()]
+                    if period_quality_flag:
+                        try:
+                            DeltaF1 = signal_peaks[1] - signal_peaks[2]
+                            f_obs = 2 / period_sy
+                            y_trumpet = utils.trumpet(
+                                DeltaF1, 1, f_obs
+                            )
+                            alias_flag = (DeltaF1 - y_trumpet) * 100
+                            if alias_flag < 1:
+                                SOCCA_opt["Period_class"] = "true"
+                            else:
+                                SOCCA_opt["Period_class"] = "alias"
+                            SOCCA_opt["Nbs"] = Nbs
+                        except Exception:
+                            SOCCA_opt["Period_class"] = "class_error"
+                except Exception:
+                    SOCCA_opt = {"Failed at SOCCA inversion": 5}
                 return SOCCA_opt
             else:
                 period_si_t, alt_period_si_t, _ = utils.estimate_sidereal_period(
@@ -254,14 +325,14 @@ def get_fit_params(
 
                 # Constrained Fit
                 Afit = estimate_sso_params(
-                    data["cmred"].values[0][filter_mask],
-                    data["csigmapsf"].values[0][filter_mask],
-                    np.radians(data["Phase"].values[0][filter_mask]),
-                    data["cfid"].values[0][filter_mask],
-                    ra=np.radians(data["ra"].values[0][filter_mask]),
-                    dec=np.radians(data["dec"].values[0][filter_mask]),
-                    jd=data["cjd"].values[0][filter_mask],
-                    model="SSHG1G2", # We should call this SOCCA
+                    data["cmred"].values[0],
+                    data["csigmapsf"].values[0],
+                    np.radians(data["Phase"].values[0]),
+                    data["cfid"].values[0],
+                    ra=np.radians(data["ra"].values[0]),
+                    dec=np.radians(data["dec"].values[0]),
+                    jd=data["cjd"].values[0],
+                    model="SSHG1G2",  # We should call this SOCCA
                     p0=p0,
                 )
                 return Afit
@@ -272,28 +343,28 @@ def get_fit_params(
             if p0 is not None:
                 if terminator:
                     Afit = estimate_sso_params(
-                        data["cmred"].values[0][filter_mask],
-                        data["csigmapsf"].values[0][filter_mask],
-                        np.radians(data["Phase"].values[0][filter_mask]),
-                        data["cfid"].values[0][filter_mask],
-                        ra=np.radians(data["ra"].values[0][filter_mask]),
-                        dec=np.radians(data["dec"].values[0][filter_mask]),
-                        jd=data["cjd"].values[0][filter_mask],
+                        data["cmred"].values[0],
+                        data["csigmapsf"].values[0],
+                        np.radians(data["Phase"].values[0]),
+                        data["cfid"].values[0],
+                        ra=np.radians(data["ra"].values[0]),
+                        dec=np.radians(data["dec"].values[0]),
+                        jd=data["cjd"].values[0],
                         model="SSHG1G2",
                         p0=p0,
                         terminator=terminator,
-                        ra_s=np.radians(data["ra_s"].values[0][filter_mask]),
-                        dec_s=np.radians(data["dec_s"].values[0][filter_mask]),
+                        ra_s=np.radians(data["ra_s"].values[0]),
+                        dec_s=np.radians(data["dec_s"].values[0]),
                     )
                 else:
                     Afit = estimate_sso_params(
-                        data["cmred"].values[0][filter_mask],
-                        data["csigmapsf"].values[0][filter_mask],
-                        np.radians(data["Phase"].values[0][filter_mask]),
-                        data["cfid"].values[0][filter_mask],
-                        ra=np.radians(data["ra"].values[0][filter_mask]),
-                        dec=np.radians(data["dec"].values[0][filter_mask]),
-                        jd=data["cjd"].values[0][filter_mask],
+                        data["cmred"].values[0],
+                        data["csigmapsf"].values[0],
+                        np.radians(data["Phase"].values[0]),
+                        data["cfid"].values[0],
+                        ra=np.radians(data["ra"].values[0]),
+                        dec=np.radians(data["dec"].values[0]),
+                        jd=data["cjd"].values[0],
                         model="SSHG1G2",
                         p0=p0,
                         terminator=terminator,

{asteroid_spinprops-1.1.1 → asteroid_spinprops-1.2.0}/asteroid_spinprops/ssolib/utils.py

@@ -418,3 +418,57 @@ def generate_initial_points(ra, dec, dec_shift=45):
                 ra_list.append(wrap_longitude(temp_ra + offset))
                 dec_list.append(shifted_dec)
     return ra_list, dec_list
+
+def gaussian_interpolate(data, factor=4, sigma=1.0):
+    """
+    Reproduce matplotlib's `interpolation="gaussian"` effect.
+    factor : upsampling factor
+    sigma  : Gaussian smoothing strength
+    """
+    from scipy.ndimage import zoom, gaussian_filter
+
+    # Step 1: upsample (mimics interpolation grid)
+    up = zoom(data, factor, order=1)  # bilinear before smoothing
+    
+    # Step 2: apply gaussian smoothing
+    smoothed = gaussian_filter(up, sigma=sigma)
+    
+    return smoothed
+
+def detect_local_minima(arr):
+    import scipy.ndimage.filters as filters
+    import scipy.ndimage.morphology as morphology
+
+    # https://stackoverflow.com/questions/3684484/peak-detection-in-a-2d-array/3689710#3689710
+    # https://stackoverflow.com/questions/3986345/how-to-find-the-local-minima-of-a-smooth-multidimensional-array-in-numpy
+    """
+    Takes an array and detects the troughs using the local maximum filter.
+    Returns a boolean mask of the troughs (i.e. 1 when
+    the pixel's value is the neighborhood maximum, 0 otherwise)
+    """
+    neighborhood = morphology.generate_binary_structure(len(arr.shape),2)
+    
+    footprint = np.ones((15, 15))
+    local_min = filters.minimum_filter(arr, footprint=footprint) == arr
+
+    background = (arr==0)
+    eroded_background = morphology.binary_erosion(
+        background, structure=neighborhood, border_value=1)
+
+    detected_minima = local_min ^ eroded_background
+    return np.where(detected_minima)       
+
+def trumpet(peak_diff_1, f_feat, f_obs):
+    if peak_diff_1 > 0 and f_obs > f_feat:
+        return 2 * f_feat
+
+    elif peak_diff_1 < 0 and f_obs < f_feat:
+        return -2 * f_obs
+
+    elif peak_diff_1 > 0 and f_obs < f_feat:
+        return 2 * f_obs
+
+    elif peak_diff_1 < 0 and f_obs > f_feat:
+        return -2 * f_feat
+
+    return 0.0

{asteroid_spinprops-1.1.1 → asteroid_spinprops-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "asteroid_spinprops"
-version = "1.1.1"
+version = "1.2.0"
 description = "Collection of tools used for fitting sHG1G2 and SOCCA photometric models to sparse asteroid photometry"
 authors = [
     {name = "Odysseas",email = "odysseas.xenos@proton.me"}