asteroid_spinprops 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

asteroid_spinprops/ssolib/modelfit.py

@@ -4,10 +4,7 @@ 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_shg1g2,
-)
+from fink_utils.sso.spins import estimate_sso_params, func_shg1g2, parameter_remapping
 from asteroid_spinprops.ssolib.periodest import (
     get_multiterm_period_estimate,
 )
@@ -25,6 +22,8 @@ def get_fit_params(
     period_in=None,
     period_quality_flag=False,
     terminator=False,
+    remap=False,
+    remap_kwargs=None,
     time_me=True,
 ):
     """
@@ -188,9 +187,23 @@ def get_fit_params(
                 rms = []
                 model = []
 
-                period_scan = np.linspace(
-                    period_sy - 20 / (24 * 60 * 60), period_sy + 20 / (24 * 60 * 60), 20
-                )
+                # Add heliocentric distance mean
+                sma = data["Dhelio"].values[0].mean()  # in AU
+
+                W = utils.period_range(sma, period_sy * 24) / 24  # in days
+                N = utils.Nintervals(sma)
+
+                Pmin = period_sy - W
+                Pmax = period_sy + W
+
+                period_scan = np.linspace(Pmin, Pmax, N)
+
+                if not np.isclose(period_scan, period_sy).any():
+                    period_scan = np.sort(np.append(period_scan, period_sy))
+
+                # period_scan = np.linspace(
+                #     period_sy - 20 / (24 * 60 * 60), period_sy + 20 / (24 * 60 * 60), 20
+                # )
 
                 ra0, dec0 = shg1g2_params["alpha0"], shg1g2_params["delta0"]
 
@@ -264,7 +277,7 @@ def get_fit_params(
                 H_key = next(
                     (
                         f"H_{i}" for i in range(1, 7) if f"H_{i}" in shg1g2_params
-                    ),  # FIXME: Harcoded N of bands, won't throw error if N>6, but to be recosnidered
+                    ),  # FIXME: Harcoded N of bands, won't throw error if N>6, but to be reconsidered
                     None,
                 )
 
@@ -300,13 +313,24 @@ def get_fit_params(
                             a_c,
                             0.1,
                         ]  # phi 0
-                        SOCCA = get_fit_params(
-                            data,
-                            "SOCCA",
-                            shg1g2_constrained=False,
-                            p0=p_in,
-                            terminator=terminator,
-                        )
+                        if remap:
+                            SOCCA = get_fit_params(
+                                data,
+                                "SOCCA",
+                                shg1g2_constrained=False,
+                                p0=p_in,
+                                terminator=terminator,
+                                remap=remap,
+                                remap_kwargs=remap_kwargs,
+                            )
+                        else:
+                            SOCCA = get_fit_params(
+                                data,
+                                "SOCCA",
+                                shg1g2_constrained=False,
+                                p0=p_in,
+                                terminator=terminator,
+                            )
                         try:
                             rms.append(SOCCA["rms"])
                             model.append(SOCCA)
@@ -421,20 +445,44 @@ def get_fit_params(
                 print("Initialize SOCCA first!")
             if p0 is not None:
                 if terminator:
-                    Afit = estimate_sso_params(
-                        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="SOCCA",
-                        p0=p0,
-                        terminator=terminator,
-                        ra_s=np.radians(data["ra_s"].values[0]),
-                        dec_s=np.radians(data["dec_s"].values[0]),
-                    )
+                    if remap:
+                        p0in = np.concatenate((p0[3:], p0[:3]))
+                        p0_latent = parameter_remapping(
+                            p0in, physical_to_latent=True, **remap_kwargs
+                        )
+                        p0_latent = np.concatenate((p0_latent[-3:], p0_latent[:-3]))
+                        Afit = estimate_sso_params(
+                            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="SOCCA",
+                            p0=p0_latent,
+                            terminator=terminator,
+                            ra_s=np.radians(data["ra_s"].values[0]),
+                            dec_s=np.radians(data["dec_s"].values[0]),
+                            bounds=None,
+                            remap=remap,
+                            remap_kwargs=remap_kwargs,
+                        )
+                    else:
+                        Afit = estimate_sso_params(
+                            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="SOCCA",
+                            p0=p0,
+                            terminator=terminator,
+                            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],

asteroid_spinprops/ssolib/pipetools.py

@@ -0,0 +1,167 @@
+import pandas as pd
+from tqdm import tqdm
+import rocks
+import numpy as np
+
+from asteroid_spinprops.ssolib.dataprep import filter_sso_data
+from asteroid_spinprops.ssolib.modelfit import get_fit_params, make_residuals_df
+from asteroid_spinprops.ssolib.periodest import (
+    get_period_estimate,
+    perform_residual_resampling,
+)
+from asteroid_spinprops.ssolib.utils import read_clean_data
+
+
+def process_single_sso(name: str, path_args: list, filtering=True) -> tuple | None:
+    """
+    Process a single Solar System Object to extract period estimation metrics.
+
+    Parameters
+    ----------
+    name : str
+        Name of the SSO to be processed.
+    path_args : list
+        Arguments required to locate and load SSO data,
+        paths to parquet files and ephemeris cache.
+
+    Returns
+    -------
+    tuple or None
+        A tuple containing:
+            - signal (tuple): Periodogram signal information (power, frequency and the 5 highest peaks).
+            - window (tuple): Window function data (power, frequency and the 5 highest peaks).
+            - noise (float): Signal noise level.
+            - name (str): SSO name.
+            - Nbs (int): Bootstrap score.
+            - npts (int): Number of data points.
+        Returns None if processing fails.
+    """
+    try:
+        if filtering is True:
+            data, _ = filter_sso_data(name, *path_args)
+        else:
+            data = read_clean_data(name, *path_args, return_rejects=False)
+        mparams = get_fit_params(data=data, flavor="SHG1G2")
+        resid_df = make_residuals_df(data, mparams)
+        signal, window, noise = get_period_estimate(resid_df)
+        _, Nbs = perform_residual_resampling(resid_df=resid_df)
+        npts = len(data["Phase"].values[0])
+        return signal, window, noise, name, Nbs, npts
+    except Exception:
+        return None
+
+
+def load_light_curve_data(file_path: str) -> pd.DataFrame:
+    """
+    Load a LCDB CSV file and return a dataframe containing objects periods.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to the CSV file containing light curve details.
+
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame containing cleaned and filtered light curve data,
+        with the 'Period' column converted to float and initial metadata rows skipped.
+    """
+    lc = pd.read_csv(file_path, skiprows=range(16))
+    lc = lc[5:]
+    lc["Period"] = lc["Period"].astype(float)
+    return lc
+
+
+def fill_missing_periods_and_powers(periods, powers):
+    """
+    Replace incomplete period or power arrays with NaN-filled placeholders.
+
+    Parameters
+    ----------
+    periods : list of array-like
+        List of period arrays estimated for each SSO.
+    powers : list of array-like
+        List of power arrays associated with each estimated period.
+
+    Returns
+    -------
+    None
+        The input lists are modified in place.
+    """
+    filler = np.full(5, np.nan)
+    for i in range(len(periods)):
+        if len(periods[i]) < 5:
+            periods[i] = filler
+        if len(powers[i]) < 5:
+            powers[i] = filler
+
+
+def collect_rocks_periods(names: list[str]) -> list[np.ndarray]:
+    """
+    Retrieve known periods from the SsODNet service for a list of SSOs.
+
+    Parameters
+    ----------
+    names : list of str
+        List of SSO names to query.
+
+    Returns
+    -------
+    list of np.ndarray
+        Each element is an array of known periods for the corresponding SSO & method.
+        If no valid periods are found, returns two arrays with a single NaN.
+    """
+    periods = []
+    methods = []
+    for sso in tqdm(names, desc="Querying rocks"):
+        r = rocks.Rock(sso, datacloud="spins")
+        try:
+            values = r.spins["period"].values.astype(np.float64)
+            method = r.spins["method"].values
+
+            if (values == [None] * len(values)).all():
+                periods.append(np.array([np.nan]))
+                methods.append(np.array([np.nan]))
+            else:
+                periods.append(values[~np.isnan(values)])
+                methods.append(method[~np.isnan(values)])
+        except Exception:
+            periods.append(np.array([np.nan]))
+            methods.append(np.array([np.nan]))
+    return periods, methods
+
+
+def match_true_period(Ps, Procks, Pmethods):
+    """
+    Match the closest known period from SsODNet to each estimated period.
+
+    Parameters
+    ----------
+    Ps : array-like
+        Array of estimated periods
+    Procks : list of np.ndarray
+        List of known periods from Rocks for each SSO.
+
+    Returns
+    -------
+    list
+        The closest known period from Rocks for each estimate & method.
+        Returns NaN if no valid match exists.
+    """
+    matched = []
+    method = []
+    for p_est, p_true, m_true in zip(Ps, Procks, Pmethods):
+        if isinstance(p_true, float) or len(p_true) == 0 or np.isnan(p_true).all():
+            matched.append(np.nan)
+            method.append(np.nan)
+        else:
+            diffs = np.abs(p_est - p_true[:, None]) / p_true[:, None]
+            min_idx = np.argmin(diffs, axis=0)
+            matched.append(p_true[min_idx[0]])
+            method.append(m_true[min_idx[0]])
+    return matched, method
+
+
+def filter_sso_name(name, path_args):
+    clean_data, rejects = filter_sso_data(name, *path_args, lc_filtering=False)
+    return name, clean_data, rejects