From 290ac2080ae1849ea5b687f5a285c94ddae2318c Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Tue, 7 Apr 2026 17:00:32 +0200
Subject: [PATCH 01/14] add ATLAS cleaning script

---
 fink_utils/sso/SOCCA-atlas.py        | 269 +++++++++++++
 fink_utils/sso/clean-fit-atlas.ipynb | 543 +++++++++++++++++++++++++++
 2 files changed, 812 insertions(+)
 create mode 100644 fink_utils/sso/SOCCA-atlas.py
 create mode 100644 fink_utils/sso/clean-fit-atlas.ipynb

diff --git a/fink_utils/sso/SOCCA-atlas.py b/fink_utils/sso/SOCCA-atlas.py
new file mode 100644
index 0000000..f1923aa
--- /dev/null
+++ b/fink_utils/sso/SOCCA-atlas.py
@@ -0,0 +1,269 @@
+import pandas as pd
+import numpy as np
+from fink_utils.sso.spins import estimate_sso_params, func_shg1g2
+import getopt
+import sys
+import pyarrow.dataset as ds
+from scipy.stats import gaussian_kde
+import rocks
+from astropy.time import Time
+import requests
+from asteroid_spinprops.ssolib import modelfit
+import os
+import json
+
+def usage():
+    print("""
+SOCCA - ATLAS
+--------------------------------------------------------------------------
+Description:
+    This script reads and cleans ATLAS v3 SSO photometric data and fits SOCCA to them.
+
+Usage:
+    python SOCCA-atlas.py -d <path_data> -t <output_dir> -n <sso_name>
+
+Required arguments:
+    -d, --path_data     Path to the input parquet dataset directory
+    -t, --target        Output directory for the resulting SOCCA parameters (CSV file)
+    -n, --target        Asteroid packed designation (SSO identifier)
+
+Optional:
+    -h, --help          Show this help message and exit
+
+Example for (45) Eugenia:
+    python SOCCA-atlas.py -d ./dataset -t ./results/ -n 00045
+
+Notes:
+    - The dataset must contain fields:
+        kast, dx, dy, m, R, delta, dm, SOE, filt, ra, dec, MJD_lc
+    - Output will be written as:
+        <output_dir>/<sso_name>.csv
+""")
+
+
+def query(name, epochs):
+    """Gets asteoid ephemerides from VOSSP Miriade.
+
+    Parameters
+    ----------
+    name : str
+        Name or designation of asteroid.
+    epochs : list
+        List of observation epochs in JD format.
+
+    Returns
+    -------
+    pd.DataFrame - Input dataframe with ephemerides columns appended
+                False - If query failed somehow
+    """
+
+    # Pass sorted list of epochs to speed up query
+    # Have to convert them to JD
+    epochs = [Time(str(e), format="jd").jd for e in epochs]
+    files = {"epochs": ("epochs", "\n".join(["%.6f" % epoch for epoch in epochs]))}
+
+    # ------
+    # Query Miriade for phase angles
+    url = "https://ssp.imcce.fr/webservices/miriade/api/ephemcc.php?"
+
+    params = {
+        "-name": f"{name}",
+        "-mime": "json",
+        "-rplane": "1",
+        "-tcoor": 5,
+        "-output": "--jd",
+        "-observer": "500",
+        "-tscale": "UTC",
+    }
+    params["-output"] += f",--iofile(ephemcc-photom.xml)"
+
+    # Execute query
+    try:
+        r = requests.post(url, params=params, files=files, timeout=50)
+    except requests.exceptions.ReadTimeout:
+        return False
+    j = r.json()
+
+    # Read JSON response
+    try:
+        ephem = pd.DataFrame.from_dict(j["data"])
+    except KeyError:
+        return False
+    return ephem
+
+
+def main(argv):
+    opts, _ = getopt.getopt(
+        argv,
+        "d:t:n:h",
+        [
+            "path_data=",
+            "target=",
+            "sso_name=",
+            "help",
+        ],
+    )
+    args = dict(opts)
+
+    if "--help" in args or "-h" in args:
+        usage()
+        sys.exit()
+
+    output_dir = args.get("-t") or args.get("--target")
+    path_data = args.get("-d") or args.get("--path_data")
+    ssnamenr = args.get("-n") or args.get("--sso_name")
+
+    dataset = ds.dataset(path_data)
+
+    table = dataset.to_table(filter=ds.field("kast") == ssnamenr)
+    data = table.to_pandas()
+
+    data["dxy"] = np.sqrt(data["dx"] ** 2 + data["dy"] ** 2)
+    data["mred"] = data["m"] - 5 * np.log10(data["R"] * data["delta"])
+
+    x = data["dxy"].values
+    y = data["mred"].values
+
+    xy = np.vstack([x, y])
+    kde = gaussian_kde(xy)
+
+    xmin, xmax = x.min(), x.max()
+    ymin, ymax = y.min(), y.max()
+
+    X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
+    positions = np.vstack([X.ravel(), Y.ravel()])
+
+    Z = kde(positions).reshape(X.shape)
+
+    Z_flat = Z.ravel()
+    idx = np.argsort(Z_flat)[::-1]
+    Z_sorted = Z_flat[idx]
+
+    Z_cumsum = np.cumsum(Z_sorted)
+    Z_cumsum /= Z_cumsum[-1]
+
+    threshold_index = np.searchsorted(Z_cumsum, 0.95)
+    level = Z_sorted[threshold_index]
+
+    cond_kde = kde(xy) >= level
+
+    data_kde = data[cond_kde]
+    data_inl = data_kde.copy()
+
+    for k in range(11):
+        shgg_params = estimate_sso_params(
+            data_inl["mred"],
+            data_inl["dm"],
+            np.radians(data_inl["SOE"]),
+            data_inl["filt"],
+            np.radians(data_inl["ra"]),
+            np.radians(data_inl["dec"]),
+            model="SHG1G2",
+        )
+        fw_model = np.zeros(len(data_inl))
+
+        for ff in np.unique(data_inl["filt"]):
+            mask = data_inl["filt"] == ff
+
+            pts = func_shg1g2(
+                [
+                    np.radians(data_inl.loc[mask, "SOE"]),
+                    np.radians(data_inl.loc[mask, "ra"]),
+                    np.radians(data_inl.loc[mask, "dec"]),
+                ],
+                shgg_params[f"H_{ff}"],
+                shgg_params[f"G1_{ff}"],
+                shgg_params[f"G2_{ff}"],
+                shgg_params["R"],
+                np.radians(shgg_params["alpha0"]),
+                np.radians(shgg_params["delta0"]),
+            )
+            fw_model[mask] = pts
+
+        residuals = fw_model - data_inl["mred"]
+
+        threshold = 3 * np.std(residuals)
+        cutoff = np.abs(residuals) <= threshold
+
+        prev_len = len(data_inl)
+        data_inl = data_inl[cutoff]
+        new_len = len(data_inl)
+
+        if prev_len == new_len:
+            print("Number of sHG1G2 cleaning iterations:", k)
+            break
+
+    data_inl = data_inl[cutoff]
+
+    rockid = str(rocks.Rock(ssnamenr).number)
+
+    data_inl["JD_lc"] = data_inl["MJD_lc"] + 2400000.5
+
+    print("Querying ephemerides via IMCCE Miriade..")
+    ephem = query(rockid, data_inl["JD_lc"])
+
+    ra_s = ephem["RA_h"].values
+    dec_s = ephem["DEC_h"].values
+
+    pdf = data_inl.reset_index(drop=True)
+
+    # Rename columns to match Fink format
+    pdf.rename(
+        columns={
+            "SOE": "Phase",
+            "dm": "csigmapsf",
+            "filt": "cfid",
+            "mred": "cmred",
+            "R": "Dhelio",
+        },
+        inplace=True,
+    )
+
+    # Add missing columns
+
+    pdf["residuals"] = 0.0
+    pdf["ra_s"] = ra_s
+    pdf["dec_s"] = dec_s
+
+    # LT correction
+    pdf["cjd"] = pdf["MJD_lc"] + 2400000.5  # MJD to JD
+
+    cfid_map = {
+        "o": 1,
+        "c": 2,
+    }
+    pdf["cfid"] = pdf["cfid"].map(cfid_map)
+
+    # Make it readable by asteroid_spinprops
+    pdf_s = pd.DataFrame({col: [np.array(pdf[col])] for col in pdf.columns})
+
+    base_kwargs = dict(
+        use_angles=True,
+        use_filter_dependent=True,
+        use_phase=True,
+        use_shape=True,
+    )
+
+    current_kwargs = base_kwargs.copy()
+
+    SOCCA_params = modelfit.get_fit_params(
+        data=pdf_s,
+        flavor="SOCCA",
+        shg1g2_constrained=True,
+        period_blind=True,
+        pole_blind=False,
+        period_in=None,
+        period_quality_flag=True,
+        terminator=True,
+        time_me=True,
+        remap=True,
+        remap_kwargs=current_kwargs,
+    )
+
+    SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])
+
+    SOCCA_out.to_csv(os.path.join(output_dir, ssnamenr + ".csv"), index=None)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/fink_utils/sso/clean-fit-atlas.ipynb b/fink_utils/sso/clean-fit-atlas.ipynb
new file mode 100644
index 0000000..348dcb3
--- /dev/null
+++ b/fink_utils/sso/clean-fit-atlas.ipynb
@@ -0,0 +1,543 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "id": "c4cd7a71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pyarrow.dataset as ds\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from fink_utils.sso.spins import estimate_sso_params, func_shg1g2\n",
+    "\n",
+    "from astropy.time import Time\n",
+    "import requests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "id": "5a3443c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def query(name, epochs):\n",
+    "    \"\"\"Gets asteoid ephemerides from VOSSP Miriade.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    name : str\n",
+    "        Name or designation of asteroid.\n",
+    "    epochs : list\n",
+    "        List of observation epochs in JD format.\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    pd.DataFrame - Input dataframe with ephemerides columns appended\n",
+    "                False - If query failed somehow\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Pass sorted list of epochs to speed up query\n",
+    "    # Have to convert them to JD\n",
+    "    epochs = [Time(str(e), format=\"jd\").jd for e in epochs]\n",
+    "    files = {\"epochs\": (\"epochs\", \"\\n\".join([\"%.6f\" % epoch for epoch in epochs]))}\n",
+    "\n",
+    "    # ------\n",
+    "    # Query Miriade for phase angles\n",
+    "    url = \"https://ssp.imcce.fr/webservices/miriade/api/ephemcc.php?\"\n",
+    "\n",
+    "    params = {\n",
+    "        \"-name\": f\"{name}\",\n",
+    "        \"-mime\": \"json\",\n",
+    "        \"-rplane\": \"1\",\n",
+    "        \"-tcoor\": 5,\n",
+    "        \"-output\": \"--jd\",\n",
+    "        \"-observer\": \"500\",\n",
+    "        \"-tscale\": \"UTC\",\n",
+    "    }\n",
+    "    params['-output'] += f\",--iofile(ephemcc-photom.xml)\"\n",
+    "\n",
+    "    # Execute query\n",
+    "    try:\n",
+    "        r = requests.post(url, params=params, files=files, timeout=50)\n",
+    "    except requests.exceptions.ReadTimeout:\n",
+    "        return False\n",
+    "    j = r.json()\n",
+    "\n",
+    "    # Read JSON response\n",
+    "    try:\n",
+    "        ephem = pd.DataFrame.from_dict(j[\"data\"])\n",
+    "    except KeyError:\n",
+    "        return False\n",
+    "    return ephem\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "id": "8f7fb7ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "kast = \"00045\"\n",
+    "\n",
+    "dataset = ds.dataset(\"atlas-sscat.v3.0\")\n",
+    "\n",
+    "table = dataset.to_table(filter=ds.field(\"kast\") == kast)\n",
+    "data = table.to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "id": "eed89836",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data[\"dxy\"] = np.sqrt(data[\"dx\"]**2 + data[\"dy\"]**2)\n",
+    "data[\"mred\"] = data[\"m\"] - 5 * np.log10(data[\"R\"] * data[\"delta\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "id": "9edbfba8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.stats import gaussian_kde\n",
+    "\n",
+    "x = data[\"dxy\"].values\n",
+    "y = data[\"mred\"].values\n",
+    "\n",
+    "xy = np.vstack([x, y])\n",
+    "kde = gaussian_kde(xy)\n",
+    "\n",
+    "xmin, xmax = x.min(), x.max()\n",
+    "ymin, ymax = y.min(), y.max()\n",
+    "\n",
+    "X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]\n",
+    "positions = np.vstack([X.ravel(), Y.ravel()])\n",
+    "\n",
+    "Z = kde(positions).reshape(X.shape)\n",
+    "\n",
+    "Z_flat = Z.ravel()\n",
+    "idx = np.argsort(Z_flat)[::-1]\n",
+    "Z_sorted = Z_flat[idx]\n",
+    "\n",
+    "Z_cumsum = np.cumsum(Z_sorted)\n",
+    "Z_cumsum /= Z_cumsum[-1]\n",
+    "\n",
+    "threshold_index = np.searchsorted(Z_cumsum, 0.95)\n",
+    "level = Z_sorted[threshold_index]\n",
+    "\n",
+    "cond_kde = kde(xy) >= level"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "id": "29fdb953",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.contour.QuadContourSet at 0x77cd07ce8520>"
+      ]
+     },
+     "execution_count": 107,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZLRJREFUeJzt3Xd8VFX6P/DPncmUZJJMGmkQIBSBEKQJghSlSpGiq64ddVd3bWv57YroomJD3P1aVhTL2lbWtioKFhQFKdIJLYDU0BNC2kwySSaTmfv7I0xImXKn35n5vF+viJm5c+fk5mbuc895znMEURRFEBEREQWJItQNICIioujC4IOIiIiCisEHERERBRWDDyIiIgoqBh9EREQUVAw+iIiIKKgYfBAREVFQMfggIiKioIoJdQPastlsOH36NBISEiAIQqibQ0RERBKIoojq6mpkZ2dDoXDdtyG74OP06dPIyckJdTOIiIjICydOnECnTp1cbiO74CMhIQFAU+MTExND3BoiIqLosvlIBW7/YIvb7d6dNQRDu6U0f280GpGTk9N8HXdFdsGHfaglMTGRwQcREVGQjbkwAR3TD6PEUA9Hi78JADL1Woy5sAuUivbpEVJSJphwSkRERM2UCgFPTMsD0BRotGT//olpeQ4DD6kYfBAREVErk/KzsOimQcjUa1s9nqnXYtFNgzApP8un/ctu2IWIiIhCb1J+FibkZWJzUQVKq+uRnqDF0NwUn3o87Bh8EBERkUNKhYDh3VP9vl8OuxAREVFQMfggIiKioGLwQUREREHF4IOIiIiCisEHERERBRWDDyIiIgoqBh9EREQUVAw+iIiIKKgYfBAREVFQMfggIiKioGLwQUREREHF4IOIiIiCisEHERERBRWDDyIiIgoqBh9EREQUVAw+iIiIKKgYfBAREVFQMfggIiKioGLwQUREREHF4IOIiIiCisEHERERBRWDDyIiIgoqBh9EREQUVAw+iIiIKKgYfBAREVFQMfggIiKioPI4+FizZg2mTZuG7OxsCIKAr776qtXzTz75JHr37g2dTofk5GSMHz8emzZt8ld7iYiIKMx5HHyYTCb0798fCxcudPj8BRdcgIULF2L37t1Yt24dunbtiokTJ+Ls2bM+N5aIiIjCnyCKouj1iwUBS5YswcyZM51uYzQaodfr8dNPP2HcuHFu92nf3mAwIDEx0dumERERURB5cv2OCWRDGhoa8NZbb0Gv16N///4OtzGbzTCbzc3fG43GQDaJiIiIQiwgCafffPMN4uPjodVq8dJLL2HFihVIS0tzuO38+fOh1+ubv3JycgLRJCIiIpKJgAQfY8aMwY4dO7B+/XpMmjQJ1157LUpLSx1uO2fOHBgMhuavEydOBKJJREREJBMBCT50Oh169OiBYcOG4Z133kFMTAzeeecdh9tqNBokJia2+iIiIqLIFZQ6H6IotsrrICIioujlccJpTU0NDh061Px9UVERduzYgZSUFKSmpuLZZ5/F9OnTkZWVhfLycrz++us4efIkrrnmGr82nIiIiMKTx8HH1q1bMWbMmObvH3roIQDArFmz8MYbb+C3337DBx98gLKyMqSmpmLIkCFYu3Yt+vbt679WExERUdjyqc5HILDOBxERUfjx5PrNtV2IiIgoqBh8EBERUVAx+CAiIqKgYvBBREREQcXgg4iIiIKKwQcREREFFYMPIiIiCioGH0RERBRUDD6IiIgoqBh8EBERUVAx+CAiIqKgYvBBREREQcXgg4iIiIKKwQcREREFFYMPIiIiCioGH0RERBRUDD6IiIgoqBh8EBERUVAx+CAiIqKgYvBBREREQcXgg4iIiIIqJtQNICIikjOrTcTmogqUVtcjPUGLobkpUCqEUDcrrDH4ICIicmJ5YTHmLduLYkN982NZei2emJaHSflZIWxZeOOwCxERkQPLC4tx1+KCVoEHAJQY6nHX4gIsLywOUcvCH4MPIiKiNqw2EfOW7YXo4Dn7Y/OW7YXV5mgLcofBBxERURubiyra9Xi0JAIoNtRjc1FF8BoVQRh8EBERtVFa7Tzw8GY7ao3BBxERURvpCVq/bketMfggIiJqY2huCrL0WjibUCugadbL0NyUYDYrYjD4ICIiakOpEPDEtDwAaBeA2L9/Yloe6314icEHERGRA5Pys7DopkHI1LceWsnUa7HopkGs8+EDFhkjIiJyYlJ+FibkZbLCqZ8x+CAiInJBqRAwvHtqqJsRUTjsQkREREHF4IOIiIiCisEHERERBRWDDyIiIgoqBh9EREQUVAw+iIiIKKgYfBAREVFQMfggIiKioGLwQUREREHF4IOIiIiCisEHERERBRWDDyIiIgoqBh9EREQUVAw+iIiIKKg8Dj7WrFmDadOmITs7G4Ig4Kuvvmp+zmKxYPbs2ejXrx90Oh2ys7Nxyy234PTp0/5sMxEREYUxj4MPk8mE/v37Y+HChe2eq62tRUFBAebOnYuCggJ8+eWXOHDgAKZPn+6XxhIREVH4E0RRFL1+sSBgyZIlmDlzptNttmzZgqFDh+LYsWPo3Lmz230ajUbo9XoYDAYkJiZ62zQiIiIKIk+u3zGBbozBYIAgCEhKSnL4vNlshtlsbv7eaDQGuklEREQUQgFNOK2vr8cjjzyCG264wWkUNH/+fOj1+uavnJycQDaJiIiI/MxqE7H5SIXk7QMWfFgsFlx33XWw2Wx4/fXXnW43Z84cGAyG5q8TJ04EqklERETkZ8sLizFywUrc/sEWya8JyLCLxWLBtddei6KiIqxcudLl2I9Go4FGowlEM4iIiCiAlhcW467FBfA0edTvwYc98Dh48CBWrVqF1NRUf78FERERhZjVJmLesr0eBx6AF8FHTU0NDh061Px9UVERduzYgZSUFGRnZ+Pqq69GQUEBvvnmG1itVpSUlAAAUlJSoFarvWgiERERyc3mogoUG+q9eq3HwcfWrVsxZsyY5u8feughAMCsWbPw5JNPYunSpQCAAQMGtHrdqlWrcNlll3nVSCIionBitYnYXFSB0up6pCdoMTQ3BUqFEOpm+VVptXeBB+BF8HHZZZfBVWkQH8qGEBERhb3lhcWYt2xvq16BLL0WT0zLw6T8rBC2zL/SE7Rev5ZruxARRRmrTcSGw+X4escpbDhcDquNN43+Yk/AbDscUWKox12LC7C8sDhELfO/obkpyNJr4U1/TsCLjBERkXxEy115KLhKwBQBCADmLduLCXmZETEEo1QIeGJaHu5aXOBxAMKeDyKiKBFNd+Wh4C4BUwRQbKjH5iLpxbjkblJ+FhbdNAiZes+GYBh8EBFFAXd35UDTXTmHYLwnNQHTl0RNOZqUn4V1s8fi3VlDJL+GwQcRURSIxrvyYJOagOlLoqZcKRUChnZLkbw9cz6IiKKA3O7KI3Eqqj0Bs8RQ77CHSQCQqW/6WaMdgw8ioiggp7vySE16bZuA2TIAsYdVT0zLC/sgyx847EJEFAXcTYsU0BQABPquPNKTXp0lYGbqtVh006CwDq78SRBlVhXMaDRCr9fDYDC4XJCOiIhcazu0UWlqwD0fFQBwfFce6Iuj1SZi5IKVTnNP7MMS62aPDfveATkMKwW7DZ5cvznsQkQUgZwNbdw5OhdLdxa3ejwzSEMeniS9Du8e3ouSKhVCSH8GuQ9tMfggIoowzpY5LzHU4601RXjthoFI1mmCflcut6TXSOXq93/X4gJZDP8w54OIKIJIqefx9Lf7MDQ3BTMGdMTw7qlBGw6QU9JrpAqXei4MPoiIIoic63nIJek1ksn5998Sgw8ioggi56EN+1RUAO0CEE5F9Q85//5bYvBBRBRBQjG04ckquZyKGljhMrTFhFMioggSiCqbrqZsejOrYlJ+FibkZYZ8KmokCpcqq6zzQUQUYeyzHQDf63m4Ci4AOJxVEay6IeSYP3//nvDk+s3gg4goAvmjzoOzKZv20uFJcSpU1VocvrZtwTA5FN2KJqGo88Hgg4jIS5F0kfTlZ3FXjVSqj+8YBkNdg6wLXkUqVjglIgoDcq4K6c2FxJcqm+6mbEr1094SvPvrUVkXvIpUoa6y6gqDDyIiyLsqZCiCIn9NxVyy45TTglcCmgpeTcjLDNveJfIOp9oSUdSTc1XIUK0C6+tUTAFAqk6NCpPjnBBAPgWvKPgYfBCRVzyp7SB3cq0KGcqgyD5l0xv2PowZA7IlbR/qglcUfBx2ISKPyTk3whtyrQoZylVg7dVI/3xuyqYn7Kvk6mPVePfXo263D3XBKwo+Bh9E5BE550Z4S65VIUMdFE3Kz8IfRnTFOxICiHvH9EDPjPhWybBWmxgWBa8o+DjsQkSSyTk3whdyXfBMDkHR+LxMSduN6JHWbpVcOa/lEknDhuGIPR9EJFkohwECyX6RvGtxQXMBLbtQXiTlUCp7aG4KMhO1KDE6/r27a4N9LZe2w3SZQR6mazlV+WiZCR9vPo4So7n5+XAeNgxHDD6ISLJQDwMEklwuki3JIShasbcE9Y1Wh89JbUOo13JxlKPUVjgPG4YjBh9EJJkchgECKdQXSWdtClVQ5Cy/xy4pToX5V/WT1IZQFbxy9zPYse5IcDH4ICLJ5DAMEGhyrAoZiqDIVX6PnSZGgQkSc0JCQcrP0FK4DhuGIyacEpFkck4gjHT2oKhtUmegSCmvXmI0y7pAmLcl4sNx2DDcMPggIo/YhwEy2xSgytRrOV4eQSIhv8fbtoXrsGE44bALEXlMjrkR1J7UxehOHy7BhqVbUVtdh/E3jUZWt4yIyO/xtG2RMGwYLhh8EJFX5JgbIVfBXtoccF2FdmJeBvZvOYz1X2/BxmVbcXTPieZtPpz3PwyffhFm3DcFWYkalBjNYZvf4y5HqSUOGwaXIIqirCqrGI1G6PV6GAwGJCYmhro5REQ+CUUpemczPASbDfH7jyKvcD8qis40P65QKnDhpXlQxiix7cedzY93uCAbuy/ogZq8bg6n+YbDMJv9WABwGYCwzofvPLl+M/ggIgoQp0HAuX8DcfG22kSMXLCyVbCjrKmFftdBJO48AFW1CQAQlxCLIZMH4JLpQzBk8kAkJMcDAI7tO4mvX/0eK/6zGvW1TUW4Grt3xKnRF6GhQzKA1hfqUPTqeMpZAHjdkM7omhYn23aHGwYfREQthOIC6SgIaMk+bLFu9li/tmXD4XJc//ZGAIDmTDmSNxUi/sBRCOfKh1tjNagcnIcX/3ULxgzo5HQ/1ZU1+OT5r/Dly9+g0WKFoBDQe9pQTP3rTIwf3h1KheDwop6ZqMH1Qzuja5pOVhf1cAiSwp0n12/mfBBRRAvVCryhKkV/xliH2GPFSN60G7qjp5sfr+uYDsOAXqjp1QViTAyMTleyaZKQHI87FtyEqXeOx7/n/BdrP9+IfV9vwqEfCnDygSuQNHEw/rr8UPsFBo1mvPTTwebv5TKcwRwleWHwQUQRK5Qr8AZrqqr9jv6MsQ5VWw9i1cJv0Wn3MQCAKAio7p2LyqF90ZDR+sIrdSbIrjoR3w8cgEpNCtJ+2QqcKsUnzy+B+MLXSO/VFeWjBqIxKcHp61m2nBxh8EFEYc9RlzoAlyvwBrqUdjCmqtp7dcqOlqLDz5uhO3ISACDGKGHo1xOVQ/q2Cww8maXSKnjrmI6TN0yG7uBxJG8uROzps0jcdwSKxkYUXznW6T7sx/+RL3cjQaPCsCAUSCP5Y/BBRGHNVTJhKFfgDXQp+uWFxbj7vc1I2rgbnTfvhsJqg6hQoOqiPFQO6QurLtbh60RIm07qsDS5IMB0QReYLugC3cHjyF6yErEnzwCiCAiu91dVa8GN72ySzTAMhRYrnBJR2LLfmbcNMkoM9XjppwOS9hGoCp2BLEVvtYl45oXv0Pndr5C6YScUVhtMXbNx7LYZKLvsIqeBhyfc5ayYunWELUYJZZ0ZqgqD5P3ah2GWFxb73EYKXww+iCgsuVo0zJMpfIGs0BmIUvR1NXX464wXELt4OVSGGlgSdCiecRlOXzMBllS929fbh5usNtdHyW1QJgiwpDTNaIg9WSq1+c2/GyltoMjFYRciCkveLhpmF6wKnVJL0UuZClp2ugJzpz2PQ9uLIAoCKof2RcXw/hDVKsntkTrc5DQoE0XoDp1A6toCaMqqAAAKS6Pk9/ekDRS5GHwQUVjyZLhEABxW6AxWKW130zylTAc+susYHrtiPspOlkOt1+HwFZeivmO6121yd/wc5azEVFUjY/mviDteAgCwaTVouHQAqvJ7BaQNFLkYfBBRWJI6XPLg+J74ZMuJ1oWwZJT0KGU6cOqpM3jy6n+iwWRGQ4oeRVePdzm9VQp3x8+es3LX4gIIoojEgn1IW1MAhaURthglDIPz8Pf/uxHThnVr7rE5WlaLjzcfR4lRWlAh50XpKLA8Dj7WrFmDf/zjH9i2bRuKi4uxZMkSzJw5s/n5L7/8Em+++Sa2bduG8vJybN++HQMGDPBjk4mIpM8muXdsT9w7tqcsq1u6y1sRADz96s/QvbsMotWG2s6ZKJ45Bjatxuk+2/byOHpe6nDTgHglbq0rw5qP10FxboilNicT4jVj8Mytw5uDt5a9OveO7YGNR8pxz38LUFVn8bkN0SLaKrB6HHyYTCb0798ft912G373u985fH7EiBG45pprcMcdd/ilkUREbbW6M4f7YRU55hZIqYLauKEQotUGU242Tl81DlAqXe4zU6/F9P5ZeGtNUfM+7KQMN1WUVGL1Zxvwy6e/Yu+GphlDCgBqnQbD/zINY24di2Hd05y+XqkQMKJHGp7/XT+HC7px9dj2QlWFN5Q8Dj4mT56MyZMnO33+5ptvBgAcPXrU60YREUlhn03Sbn2RMPngdpvzYLNBd7ipcFjlxf1cBh73jumBET3SWt0xv722CC1X7xIE4I5Rue2Oi8lgwprPN2Llx+uw65c9sJ2bhSIIAvqP6YtxN47GqN9dDF1inOSfLZC/m1D1Evjzfe37WrG3BO/+erTd85FeGTbkOR9msxlms7n5e6PRGMLWEFG4kTqbRI7c5TxoT5VCWWeGVatBXacMl9t2T49v7t1ZXliMt9YUtRt+sYnAW2uKMLBzMi7tmoSCnwvx+b9XYt9PO2E1nx8i6TOsJ8ZcNxKjrxmO1Kxkr342IDC/m1D1EvjzfR3tq61gVOENpZAHH/Pnz8e8efNC3QwiCmMtZ5OE09i5u7wV3bGmQlyNOi2ERitEtfPSTE9/swexKgUm5GW2zyOx2qAuq4S2pBzaM+V44b/f4qUz5bA12po3MafqgcG9cM8Dk/H7Sfn++QHh3wXdQrVWjz/f19m+HInkKckhDz7mzJmDhx56qPl7o9GInJycELaIiMJVuI2du8tbqc3tiPSCfUC5AZ0/WIba3I6oz0pDfWYqLCn6ViXNK4xm3PPWetzaNw3VG/chpcIAdbkBqgoD1OVVUFhtrd7bBsCSqENNz86o7tsd5oxUCIKAR345Bn2nVNkdLynJuYHoJfDn+7ralyuROCU55MGHRqOBRuM8c5uISIpQrmDrC5e5ETdNQtf7RuLhyc8BlUaoK88PS1vVKjQm6KBoaICyvqG50NcaAI5+SqtGBXNGU+BizkxFfWZau+m6cu7ql5KcG4heAn++r7eF8SJxSnLIgw8ikodwGq5oK1R3xf7iLjfiw/2v4N13fsEXX28HTpRCc6YcygYLlOVV7fZl1WrQkKpHQ0rTlyVVj4ZUPSxJCW4XfwPk29Uv9e7f370E/nxfT9sWyVOSPQ4+ampqcOjQoebvi4qKsGPHDqSkpKBz586oqKjA8ePHcfr0aQDA/v37AQCZmZnIzMz0U7OJyJ/CbbiirVDdFfuTq9wIfVoiHpw9HV0nDMKDn+0EbDaoy6qgrKuHTaOGTaOGVdv0LxQKJMWqYKizeNy935Lcuvql3v37u5fAn+/rSdsifUqyxwvLbd26FQMHDsTAgQMBAA899BAGDhyIxx9/HACwdOlSDBw4EFOnTgUAXHfddRg4cCDeeOMNPzabiPzF1cqw4bL6aKjuioMtU39utVqFAg3pKajrkg1zZhosyYmwxWoBRdNH+m0jcgE4X01XCrl19duTc539DAKaAmZ/9xL4833d7aslXxYfDAceBx+XXXYZRFFs9/X+++8DAG699VaHzz/55JN+bjoR+UrKyrDhsPpoqO6Kg03qhfDesT2crqb7+g0DQ3IR95U9ORdwHlQFopfAn+/ral92fxjRFR/fMQzrZo+N2MADYM4HUVSLhOEKQHqp9WBeUAORQ+NJVVdXeSQKhSC5MqychKqonD/f19m+wmmY0x8EURRldUtjNBqh1+thMBiQmJgY6uYQRbSvd5zC/Z/scLvdK9cNwIwBHQPfIB/Yh48AxxfUYHZhBzqHxh/7D+c8n0iqcBqOCd7OeHL9ZvBBFMU2HC7H9W9vdLvdx3cMk3XPh50cLqjOpvz6Owjyx8UrEi+A4SISj70n128OuxBFMbkMV/jrgzjUpdaDOeXXH5VD/Vl9lKSTQ5Acagw+iKKYpyvDBoK/P4hDeUGNlBwa8p2zgDpci+H5G4MPoigXypVhI+2DOFqm/JJrzgLquVPz8PS34VsMz58YfESYSBxHpMALxXBFuFcldSRapvz6U6R9ZrkKqO/+qMDla6OpZ4zBRwThOCL5ItjDFZE4RCGXHJpwEWmfWVLq5kgRDT1jHhcZI3mKhCqVFF0icYgiVIWwwlEkfmZ5u3BcW856xqw2ERsOl+PrHaew4XC57Iv/ucKejwgQid3XFPkidYgilDk04SJSP7N8DZRd9YxFWi8Rg48IEInd1xT5InmIItRTfuUuUj+zPF04TursskhLzAY47BIRIrH7miJfpA9R2HNoZgzoiOHdU8P25wiESP3MsgfUrmSdW1/H0bo7joKISFl/qS32fESASO2+psjHIYroFKmfWUqFgOn9s/DmmiKn20zvn4UpF2bj8vwsST1jkdpLxOAjAkRy9zVFPg5RRJ9I/cyy2kQs3ek6UXbpzmI8PKmP5NllkdpLxGGXCBDp3dcU+ThEIU2kzHaI1M8sKbNd7L0UUkVqLxF7PiIEu6+JIlukzXYIx88sdwXRAtFLEam9RAw+Igi7r0nuIq2aZbBE4mwHILw+s6QEf4HopZDD+kuBIIiiKKt+O0+W5CWi8BFpd+7BYrWJGLlgpdPufPud77rZY8PuAhQunAV/9qNtD/7svyt3vRTe/K7C4e/Hk+s3ez6IKOAi9c49GCJ1tkO48LQgWqB6KcKpl0gKJpwSUUCFW50CuSV1Rupsh3DhSfAHnM9laVvHI0Wnxm0jukIfq/b6nIqkxGz2fBBRQIXTnbscu7YjdbZDuPAm+GvZS/HT3hIs2XEK5aYGvPvrUbz769GQn1NywJ4PIpmR2523r8Llzl2uC53ZZzs4u8cV0BQghdtsh3DhbfCnVAgw1DUFHBUmS6vnQn1OyQF7PohkRI533r4Khzt3OS90FqmzHcKFt1Nd5XxOyQF7PohkQq533r4Khzt3T8f1g81ZHoGz9UDIf7wtiCb3cyrU2PMRYVhHITxF8l1SONy5h8PQUKTNdggn3hREC4dzKpQYfESQSOyyjxbhlJTpDblXswyHoSEAktcDIf/zNPgLl3MqVBh8RAjWUQhv0XCXJOc790gtYU3+5Unwx3PKNeZ8RIBwq6NA7UXLXZJc6xRE6kJnFDo8p1xj8BEBmNgU/sIhKTPSMamT/I3nlHMcdokA0dBlH+nCISkzGsh5aIjCE88pxxh8RIBo6bKPdHJPyowWTOoMb3Kc8cdzqj0GHxGAiU2Rg3dJRN7jjL/wwZyPCMDEpsgi16RMIjmL1CJ9kYrBR4RgYhMRRSvO+As/HHaJIOyyJ6JoFOlF+iIRg48Iw8QmIoo2nPEXfhh8EBGFCTnO5JADzvgLPww+iIhCxJNggjM5nOOMv/DD4IOIKAQ8CSa4dpNrLNIXfjjbhYgoyDyZFsqZHNJwxl94Yc8HEVEQuQsmBDQFExPyMqFUCJzJ4YFQzfhjLo7nGHwQ+QE/fEgqT4MJzuTwTLBn/AU6FydSP1sYfBD5iImA5AlPgwnO5JAvb3NxpAYUkfzZwuCDyAdMBCRPeRpMRMNMjnC8u/d0+MxOakAR6Z8tTDgl8hITAckb9mDC2aVVQNPFyB5MRPraTcsLizFywUpc//ZG3P/JDlz/9kaMXLBS9muxeDJ8Zic10TgaPlsYfBB5yZsPHyJvgolInckRzovBeTp85klAEQ2fLRx2IfISEwHJW/Zgom33e6aL8fxIW7vJ22ELuQzReDp85klAEQ2fLR4HH2vWrME//vEPbNu2DcXFxViyZAlmzpzZ/Lwoipg3bx7eeustVFZW4uKLL8Zrr72Gvn37+rPdRCHHREDyhTfBRCSt3eTNFGI5JWB6movjSUARDZ8tHg+7mEwm9O/fHwsXLnT4/AsvvIAXX3wRCxcuxJYtW5CZmYkJEyagurra58YSyYmnY/dEbdmDiRkDOmJ491QoFQKsNhEbDpfj6x2nsOFweViP67vi6d293IZoPB0+8ySgiIbPFo+Dj8mTJ+OZZ57BVVdd1e45URTx8ssv47HHHsNVV12F/Px8fPDBB6itrcVHH33klwYTyUWkJwJS8IVr8qU3PLkYyzUB05NcHE8Cimj4bPFrwmlRURFKSkowceLE5sc0Gg0uvfRSrF+/3uFrzGYzjEZjqy+icBGpiYAUfHK7sw80Ty7Gck7AnJSfhXWzx+LjO4bhlesG4OM7hmHd7LHt/vY9DSgi/bPFrwmnJSUlAICMjIxWj2dkZODYsWMOXzN//nzMmzfPn80gCqpISwSk4PM2+TKcebIYnNwTMKXm4niaaBzJny0Bme0iCK0PjCiK7R6zmzNnDh566KHm741GI3JycgLRLKKAiaREQAq+aF2/RerFONgJmIGcUeNpQBGpny1+DT4yMzMBNPWAZGWdj+BKS0vb9YbYaTQaaDQafzaDiCKQXKZYBkIo7+xDfVylXIyDWeU1GDNqIjWg8IRfg4/c3FxkZmZixYoVGDhwIACgoaEBq1evxoIFC/z5VkQUReQ0xTIQQjW1Ui7H1d3F2JMhGl84LGlus+Hs6Urc8/Z6vHj9QEwe0AlKlRJKpdKn94p2HgcfNTU1OHToUPP3RUVF2LFjB1JSUtC5c2c88MADeO6559CzZ0/07NkTzz33HOLi4nDDDTf4teFEFB0ifY0LIDh39m17OCpNDbjno/A5rpPys3Dn6Fy8vbYIYotGCwJwx6hcn9tqabTi6bfXIuHAKagqjVBXGKCuMEJVVQ3BZgMALHz1E9iLTOj0cRh34yjMvG8ycnp19Om9o5EgiqJHc5N++eUXjBkzpt3js2bNwvvvv99cZOzNN99sVWQsPz9f0v6NRiP0ej0MBgMSExM9aRoRRRirTcTIBSud5kPYL8rrZo8N+yEYe5AFOL6z9yUYcNTDoRAAZzNT5XhcnQWhQFN7PT0+VqsVRbuOY9fqvdi5eg+2rtqDBmOtV20bc/0IzP7gPihjors3xJPrt8fBR6Ax+CAiuw2Hy3H92xvdbvfxHcMiYgw9EMMgri7a7sjluPorCC0uOoOCFbuw7add2LGyENUVNa2et6liUJ/dAea0JFiSE2FJ0aMhJRGNCTpAFCHYbHhhZj4u75OOQzuO4qtXv8PGZdsgiiL+8NwNuO6RK/35Y4cdT67fXNuFiGRL7lMs/c3fUytdTeGVQi7H1dvZQJYGC3at3ouNy7Zh8/LtOH2opNXr1DoNKjPSUJeTibpOGajPTAOUTspfCQJEhQKdspKQmJqAQeP6YdC4fvjh/VX45+2v44MnPsXFUwcht18XAKFP5JU7Bh9EJFvRsMZFW/6cCeHuou2OXI6rJ0FodWUNNn1bgA3LtmLrDztQa6xrfl6hVKDPsJ4YPL4/Bozrhzt/OYHimgZJ+3aWdzNx1mVYt2QTNi7bhhdufQ2vbnwOP+0/264HK0WnwpUDOmJ8XiYDETD4iFqMyikcBHOKZSTytudCbsfVXRCkNNVBd+gElm/YjEUb9sPaaG1+LjlDj4unDsbQqYPQmNsRRghIT9DCKIoorjks6f1dzagRBAEPvvkn/GHtgzi0vQgvv/ANXqtWtTtfK0wWvPPrUbzz69GImqnlLQYfUUgu0+uI3AnWFMtI5U3PhRyPq6MgVFldi/iDxxC//yhiT5ZCEEXY52F2zc/BJdOHYNi0i9BrSHf8uPcMHl62F8WbdjbvM04lPTnUWQVSu5TMZORdcgE2f7cdSzcehdi3p8v9yXVGUTAx+Igy0TBtkSKLpyWp6bzBXZKRolOhwmRxuk3bWS9yPK72IPS+19dCd+Ao4vcfQ+yp0lbbZOTlYOqNozDqdxej0wXZzY87+8yrtVghxdypfXDriFy3gZg9n+RsvM7tPiO1ZL4nGHxEkWhcP4IiQySvcREo9h5OZ4GH/cgtvH4gknWakB5XV8PAxopqrP5sA35avAZd1+9v9bq67A5Q9O+Be+6biN9Pal/OwZeEW/vQk5TAo8FsaQ4+GlKSJO0/UkvmS8XgI4pE6/oR0SZS83lYklo6d9NrBUtjUw/HVReGvIfD4TCwToUbEmwoX7MLm74tQOO5XgpBEJA/sjdyLu2H9BF56NbDdfKmtwm3ngw92Ww2vPfYx7DZRGgT42CNj/XoveQyoyjYGHxEkWibthiNmM9Dre72RRHa4rOIPXEGqspqqCqNUFUZoaquhVqrwqn6K2B6ZCZ0iXEhaWurIMlqQ9zxYiTsK0LswWNYaj7fY9OtfxeMv+lSjLl+BNKyXSfBtgy+D56p9qpdUoee6kz1WHDzv/DrV1sAALc+eS3+Wec8QdoRucwoCjYGH1EkGqctRhPm8xDQdLdfeqoCSXuOQL/7INQVBofbNdRb8MnzS7D8nZ9xy5PXYsod44NaodNqEzHv6z3QnChBwr4ixO8/ipg6c/PzjfFxsA3siXf+dTN69O8iaZ+Ogm9P3DK8CybnZ7XrTXHUm1hZXIHHZyzAwYIiqNQx+Ou7d2PsDaOga1Gp1hW5zSgKNgYfUYTTFiMX83kIAAp+2oVX5n6G3M0HIJwrXm1TxcDUrSMaUs9V7UxOgCUpEfd202HXG9/h5IFi/Ouef+Orhd/jiS/+hs69A79OSfGRM3jnpe+gWbwGOYbzVUYb47SouaALqvvkor5TBiAIOBsfjx4S9ulLJVe7yflZ7Yb22gU0oohOp0vQYcVG1JQakNQhEU8ueRh9L+kFwHmCdEtynFEUbAw+okggpi1Gan5BuGE+T3Q7susY3nr4Q2z7sWkqqYCmZExjv56o6d0VNo263WuGTRuC++4Zj2/eWIEPn/ofju87hQ+e+BRzP30oIG2srqzB+q+34KcPV2PHqj0AABUAq1oF0wVdUJ3XDbWdMwFF6wqjUoaBfa3kCjTN+qk0tS441jKgERosSCw8hKSte6GuqkYNgNTumXjpx78jKzej1etaJkiv2FuCr3acRkWLfctxRlGwMfiIMv6ctsj8AvlgPk90KjtVjg8e/xQ/vP8LRFGEqFDAMKAXDAN6oSEtyeFrWvZwKhUCZt43GR17ZuLRKc/h2J4Tfm1fTZUJG5Zuxer/rce2H3e2Shztdklv/JrcATU9O0NUOb8USRkG9rWSK9A03fiejwqwSNE0PGkPaJRGE/QF+6DfeQBKc1MAYdWoYex/AWouH4L0LukO92dPkB7ePRWPTc3jTVobDD6ikD+mLTK/QF6YzxNdGi2N+HTB1/jk+SWor23Kk8ganY8NvS6AJdn1gl4i2vdwdurVVBfj9KESWK1WKJXe537YA441n2/Ath93wtLQ2Pxc1/wcXHbtCIy/eTTSctIwcsFKVLsJGipNZpfPA9KD6kl9M/HDnhKXPSTzlu3F+D4Z+PyLLRD/sxxdDxxrHsJqSEpA1UV5MOb3gKhWAWZRUm8iZ2q1x+AjSvnyx8D8AvlhPk/0OHngNJ674WUcLCgCAORd0gt/XHAzbv7pGCx1zouJ2d0+omu7G4P0zmlQaVSwmC3YsbIQgyf0l9QW+7BrcUUNqgoO4djybdj83fmpsQDQuU9HXHbtCIy+Zhi65OW0ev3cqXm4+yPXyZmPflWIy/OzXH6WSA2qh3RNxvI9JY6ftNmgLq1E/fqTuO3Db1Dy20kknHuqNicTVUP6wtS9EyC0bgd7E73D4IM8xvwC+WEZ8uiwYvEavHzXW2gwmRGbpMN9/7od428chY1HKlBVd8j9DgBMyMts95hSqcTAcfnY/N12PDr5WVz3yJW46fGroVKrnO7nfz/vw79e+xmNe4oQd/Q0FJYWPRx9czDqd8Mw+prh6No3x+k+9LHO929XVWvBxsPlGNEzzek2UoPvFF2L3BdRhLrcgNjjxYg7VozYEyVQ1jcNq5QAiFHHoLxXLqoG90FDuvOgnb2J3mHwQR5jfoE8sQx55Koz1WPOzQux56tNAIDanAwcuWI0Hj9hgXVPCeosNkn70cfGOO39mrP4frx2/7v46cM1+Oi5L7Fl+XbM/s99zb0VJmMtCtf9hp2rCvHLsm04e+A0Wl52G3WxqM7rhur8Hvh/D46TdL5tOFImqd0bjpS5DD6kBN9/vaQTKrceRMra7dCWnIW2uKw52LCzqlWoy8nADbddhhv/eBmmvrMVFhczVtib6D0GH+Qx5hfIF8uQR56TB07jr1OfR/nhYogAKi7pj4pL+gMKRXOO1e8GSZseO6FPhtNzIT5Jh9kf3IdhV1yEV+56CwcLinDX4NkYd+MoHC08jgPbjsBmPR/kiADqszugNrcjTN06wZyZCgiCh8OuUs9L99s1B9+fbUfl0TNQn62CuqwSCVVG6A3VeOMFIwCgZV+sLUaJ+o7pqO2chboumajPTAMUCgy69mKkpOvZmxhADD7IY8wvkDcmt0WOY3tP4IFRc1FTaUKjLhYlV4xGXZfzPQr2HKuf9pU63UdLI3o47z2wu/Sa4eg7ohf+7w+vY+sPO7H83ZXNz9lSElHdMQN1XbJg6poNW1z7GwxPhl2Hd0/FwlXuh4va7qehvgEnDxTj+L6TOLH/NE4dKsbpQyU4dbAE8eXViG/zehOaZtgk52bgaFw86rPSUJ+VBnOHZMBBcm1ZTVOSK3sTA4fBB3mM+QVEgVd5pgp/v2I+aipNqM9Mw+mrxsIa374MugigSkKiKQBk6qWtO5KWnYLnvnsMK/6zGvu3HEJDdge8cdIMS6L7FVvtpAy7DuuWiqQ4Fapqnbc/xWqBuKcI73/wEw7vPIrj+06ipKgUNpvzOSspWcnomp+D3L456JrfGV365qBLXifsLK3F9W9vdNuulr227E0MDEEURV/qsvid0WiEXq+HwWBAYqLrKWMUWqzzQRQY9bVm/HXME9i/5TD0OWkomDHeYS+DJ7L0WqybPdbji6bVJmLkgpUe19H4+I5hknrglhcW488typHHVFVDd/gE4o6XQFNcBlVNrcPXxSfp0LlPR+T06oiOPbPQsWcmOvbMQnb3DMQ6WdzN/rO467X15jiRZ9dv9nyQ13hHQOR/NpsNz9/0CvZvOYzE1AQMfOoWbN1X4fN+ve2N9LSAl6fDrhN6p2Nu3yR88O5qYE8RNGVVrZ5XKAR07tMJFwzpjp6DuqFLXid0yeuE5IwkCIJnP0+49tpGYiVpBh9ERDKyd8OB5lVSH/v0Idy98YzP+3xwfE+veyM9mbUm9QJeV1OHrT/sxPqlW7Dp2wJUV9RAY9+HQkCXi3pg3JVD0feSXugxsKvTngxvhFseR6T2MDP4IK9F6h8FUSjl9uuMpA6JqDprxOpf9qGkwffl7rumSc/VaMuTWWuuLuB1pnqs+2ITfvnsV2z/uRAW8/k8j4RkHQZNuBDDrrgIQycPRGJqQrvX+1O49NpGciVpBh/klUj+oyAKJV1iHGY9dR1euest/Pyvb6CYNQO2WI37F7rgy7T3toutOZIUq8JrNw7CsG6prS7goihi/5ZDWP7OSqz65FfUVtc1P5fdPQPDpw/BJTOGoO8lvaCM8b6kuzfkPiss0itJM/ggj0X6HwVRqE3+w1gsfX05inYfR+a3a1E1sBfqO6Y3rU7rQZ6DN9PeW+YXpOk0eOqbvW5f89yV+a2m8ZadKscvn67Hjx/8gqLdx5sfz+qWgYmzLsPIqy5Gl7xOHudsRJNIryTN4IM8Ful/FEShpoxR4s8v3orZE56C7shJ6I6cBACIggBrrAY2rQbWWA2sulgo0vSo0cXBkpTQ9JUYDyiblqV3tIicK46GUqU4WFqDmioT1n6xESs/Xoedq/bAPpFSrVVh1O+GYdLtY3HhpXlQKBQe7TtaRXolaQYf5LFI/6OgwInErP1AGTSuH/7x8xP4z+srUPDTLqgMNRBEETG19UBti7+tA0DLrBBLfBxOXzMBDR2SPXo/Z0OpLtlsiCs6jY+/XoXvj5yEtcWCcn1H9MLY60dhzPUjkJDctuwXuRPplaQZfJDHIv2Pgpr4O1BggrLnBozJx4Ax+U3H7stdKD1jgLLODGWdGakKGybnJOLHdQfQcKYKKkM1VFXVUNXUouP/VuDEjVNg1cdLGgJ1NZTqiKrCiMTCg0gsPIyYc3U4rAC69M3BuBuaAo7Mrum+H4AoFumVpBl8kMci/Y+C/B8oMEHZN85mZ2wuqsDbOD8zRFFvRqePvoemrAod//cjTtx8BYoNcDsE6raWhyhCU1LeNAR0+CS0JecXhLPGamDM6wZjfg/Me2wKLpFQwp3cC9eaJFIx+CCPRfofRbTzd6AQ7gnKchkqcjQ7o+3Qpk2rwalrJiBn8XdQVxiR8f2vKJ5xmdshUEfPK6tNiD1xBnHHTkN35CRiTOe3EQUBtbkdYezXA6buORDPzVQ5e25NFPKPcKtJ4gkGH+SVSP6jiGaBCBTCOUFZ7kNFjoY2rQk6FM+8DDn//R7xB44hadtepN853OV+0nRqqMoNiD1VitiTZ6A9eQbqqurW+1WrUNc1G6ZunWDq1tHhOjMcavW/cKlJ4ikGH+S1SP2jiGaBCBTCNUE5HIaKnA2BmrM64OzYIUj/aRPSftmGmg3DcMiYA1EUYbOJEG02VJRUYf/mQ/ht80Hs33IYXQ2t11ARBQHm9BTU5WTC1L0j6jtlQHSwAizAodZAk3tNEm8w+CCfROIfRTQLRKAQjgnK4TJU5GoI1DiwN2JPliLhtyK8cMurbvcVo1GhukMy6jploi4nA/XZHWDTqJuHUu8cnYu31hQB4FAr+Y7BBxE1C0SgEI4JynIdKnKUf+J0CDQpFnPeuwtb53+G/ZsPQVAITTU2BEChUCAuMRa9LuqOXkN7ovfQHuian4Of9p/FvGV7Ue5kKHVg52Sfh1rlkkNDocXgg0KGH0LyE4hAIRwTlEM9VOTob2PF3hKX+SfOhkCnfzVb8vu6G0r1dahV7jk0FDyCaC9DJxNGoxF6vR4GgwGJiYmhbg4FCD+E5Mue6wA4DhS8zXUIp9/5hsPluP7tjW63+/iOYX7v+XB0nJLiVKiqtbTb1tffSTA5y6EJp5+BXPPk+s3gg4KOH0LeC1ZvUaAChXDp7bLaRIxcsNJtD9C62WP92n5vqowGqi3+ZD+ezoaywuFnIPc8uX5z2CXKiKIIS0MjLGYLGuotgD32PLfAk0IhQB2rhiZW7XANBl8vHuGSyCdHwew5CNRMpnBJUA7FUJGnVUbtfMk/CVYwKNccGgodBh9hxmazoabKBGN5DYxlRhjKqlFdUdP0VXn+X5OhFrXGuuZ/a421MNc1NAUcEml1GsTGaxEbr0VSuh4WXSz2mKwwqtRojI+DJSURyd0y8cTVAyRf/Pgh5J1QTPsMl0AhUIJdy8ZtlVE3PM0/CWYwG+ocGpIfBh9BJooi6mvNqC6vhrGiBsbypoChKUiobRU01JnqUW+qR11NParLa1BVaoCxvBo2m/9GygRBgLORt3qTGfUmMyrPGHD68BkAgBpA2+LJz7+sw5IBXXHR0O7oO6I3+o/pC11i+wJEAD+EvMHeotAJZi0bX895T2YgBTuYDcfp1hRYURF8BLJrscFsQc25Hoeqs0YYy6pb/GuAocwIw9mmHgr7vxaz9N4HZ+ISYpGYloDE1AQkpsYjISUeCcnn/9Ul6aBLjEVcYiziEuMQlxgLbZwGaq0Kaq0KKq0aKnUMBKH1cbDZbDDXNTQFHjVNgU+NoRZ3v7kO1aUGxNTUNn0Za6Eur0KMqQ4qowlH1uzBkTV7gH8uhUKpQN7wCzB4Qn8MntgfvYZ0bx7C4YeQ59hbFFrB6gHy9pz3dAZSKILZcJxuTYEV8cGHJ12LDWYLqs5UoaKk6auypAqVZwyorqhBjcGEmkoTaqqa/rUPb9SbvFvLIEalRGJqQlOwkBKP+CQd4hJjoUuMg04fh7jEOMQmaKHVaRGr0yAhJR76DonQd0hEYmoC1BqVT8fFGYVCgVidFrE6LZCuB9CU+X+yUzbQKbv99nX1UJdVQVNWhSmpKhRvO4RTB4tRuO43FK77DR888SlyemXjukeuxNgbRvJDyAvsLYoO7v42HPEm/yQUwWw4TremwIro4MNp12JlLe5/8Sf8uZceiYYaHN1zHMf2nERJUanTIQhXFAoBuiQdkjokIjEtoenf1KZAoeVj+g6J0Kc1fa+N07TrdZArVxc1W6wW9TmZqM/JxLDrBmDGgI4oLjqDghW7sG3FTmz7cRdO7D+Nf9z2Gj6c9xmufXgmHpvYG/f9bzc/hCRib1F0cHeBFtF+yq03+SehCma5HhS1FLHBR8uuRaHBAm1xGWJPlUJ76gy0p89CabbgOwevi1EpkZyZhJTMJCRnJiE5PQmJqU09E/HJ8UhI1kGXpENCSjwSz/VaxCXGOpwZEik8vfhl5WZg6p0TMPXOCTAZa7Fs0Y/44qVvUHL0LP5199tIyUrGXXdejiUxehRXn+854oeQY+wtih7uLtD+yD8JZTDL9aDILmLrfPy05RgeevxLxO8/irhjxRDa/JhWtQoN6SkYPaoXhg7vga59c9AlrxOS0vVh0yMRLP6oeVBfa8b3//4Zn/1zKcpOlgMAcgZ1xxVPXQ9ldho/hNwIVOEvkqdA5qmFqoYJRb6oLDJmtYlYs+sU1n+xAcdX7ULRpgMQrbbm5y2JOtRnp6OuUzrqs9NhTk8GFAq8cm6owFvhUjTJV/64+C0vLMa8JbtR98sOpK7bDoWlEaJCgYtvG4u5r9wKbZwmMI2PEOFUIZTkjcEsBULIg4/q6mrMnTsXS5YsQWlpKQYOHIhXXnkFQ4YMcftab4KPj7/diTee+woxW3+DwtLY/Hh9RipqenVBzQVdYUlxvC9vyyNbbSIWrjyId9cVwVB//j2T41S4cmBHTMjL9CkQkWNQ48vFr23+TYzRhA4/b0L8weMAAH3HVDz2wT0YOLZfoJofEeR4XlB4YjBL/hby4OP3v/89CgsLsWjRImRnZ2Px4sV46aWXsHfvXnTs6LqXQWrjbTYbtny/Hf9+/msc/XVf8+PmVD2q83ug5oIusCQ7f70vXYvLC4vxyJe7Ha610JK3f8i+fCgE+uLkzf5dlVbWHTyODj9tgqraBIVCwP1v/AlT/jjOb+0lIucYzJI/hTT4qKurQ0JCAr7++mtMnTq1+fEBAwbgiiuuwDPPPOPy9e4aL4oitv64E+8++hEObS9qegxAbbdOqLooD7VdsppLhds5m1XhTdeip2svCB6+jy/rnsj1TsbdIl1CgwXpKzYicc9hAMCtT12HGx67irk3RERhJKRruzQ2NsJqtUKrbZ0pHRsbi3Xr1rXb3mw2w2w+P+PBaDQ63fdvmw/inTn/xY5VewAAGp0WJXndYRjQy2UvR9voQxCAO0blOr0gO7sb8HbtBakFe7wp/mNv64q9JXj316PtXhfI8ttSuZuyJ6pVODNlJMZc3A3b3l2B9x//BBUllbj7ldugVCqD1EoiIgoWvwcfCQkJGD58OJ5++mn06dMHGRkZ+Pjjj7Fp0yb07Nmz3fbz58/HvHnzXO6zuOgM3n74Q6z9YhMAQKWOwfS7L4du8lDM/bnIbZva9u3YROCtNUUY2Dm53QXZVe+BPlbt8doLnhTs8aT4z9DcFCxceRDv/XoUVXXOh3/cBS3B6G6VNGVPEDBjzu8wrH8OXn/gPSx9/QdUlhowZ/FfoFIHpqAaERGFRkDqfHz44Ye4/fbb0bFjRyiVSgwaNAg33HADCgoK2m07Z84cPPTQQ83fG41G5OTkAACsViu+Xrgc7z32MeprzRAEAeNvGY1ZT/4eGV064I4PtvjUzrYXZHfrHdw+oqvX7/XpluP4vrAYXVLicPPwrlDHtK8LIrWoz4q9Jbjrv9vc5pzYtQ2Agjk8Y7WJsNlEJMWqnAZJLetUKO+bjOQMPRbc8irWft40VPPYxw+wB4SIKIIEdKqtyWSC0WhEVlYWfv/736Ompgbffvuty9fYx4x2b9qDtx5YjH0bDwIALrw0D/e++gfk5ndu3vamf2/CukNlPrXRPtvFVVIk0HSBTNapUGHyfV0Wxblhn4cn9cHmogqUGOtRUWNGmcmMRb8c8Xn/zrxy3QBoYhRe55R4ylGQ05az99364048Pv15WBoaMf3uy3Hvq39gDggRkYyFNOejJZ1OB51Oh8rKSvzwww944YUXJL/2wVGPAxYBcQmxuOOFmzHljnHtqojmpsVh3SHf2mjvbZAy5FFhsiBFp0aFqcGn97SJwJtrirB443GYGqw+7csTafEa/PV/O4OyoJTUxFxnVU0vmtgfs/9zH569/mUsff0HpGQm48a//86nNpF7nP1ARMEQkODjhx9+gCiK6NWrFw4dOoS//e1v6NWrF2677TbJ+2hsaMTIacPwl9fvQIdOjnMlZk/qgw83HveprfZ8BKlDHjMHZOO9X496nHTqSLACD/uwBkQEZUEpKYm5SbEqvHbjIAzrlur04nbptZeg8owBr93/Lt5//BMkZ+gx5Y7xXreLXJPrbCkiijwBWZDEYDDgnnvuQe/evXHLLbdg5MiR+PHHH6FSSU8cfOjfd+Gpr2c7DTwAYPcpg9dtFND0wWpfD0PqOgYT8jKx6KZByEwMj0W8Wi7WViZxBV5fF5Ry14sEAFV1FigEwe1d9cz7JuP6OVcCAF656y2sW7LJp7aRY/aeqra/N3u+0/LC4hC1jIgiUUCCj2uvvRaHDx+G2WxGcXExFi5cCL1e79E+Lr1muNsxfm8vko5WT7Uv3uXsHdsGK/BL30fgZeq1zfkUwVpQyt+rZt72zPWY/IdxsNlEPHfDK9ixqtCX5lEb7qZ4A03DcVZbeJzzRCR/Yb0Uq9SLZIqudY9LywuynX05a1eemJbXNNNkcQFKjNJ6EUKtxFCP7ccrAZwPsJxpH2B5x99BjiAIuH/RHRgxcwgsZgv+fsV8bFux05cmBoXVJmLD4XJ8veMUNhwuD8rF25v39GSKN4WvUJyPRM4ENOHUF5uPVGDMhQkuu+WH5qYgKU7lcsppUpwKG+eMx7ZjlW6T6CblZ2F8XjpW7C1t99z4vHRMyMvEyAUrw6TPo4mIpuRWAJgzJQ/T+2c1f+9Iy94gbwViCXhljBKPfvQAnvzdP7Hl++2YO+15PPPtoxg0zv1aMKFIogxF/oS37+nvniqSH+bzkNzItufj9g+2YOSClT6PNQto6tUY3j0VMwZ0xPDuzhMc53+312HgAQAr9pbi/k+2e1xkTC7eXluEZTtP4y0Xgcf4vHSPP4gc3U217EVqe6QdDXlJpdaqMW/J3zDiyqGwNDRi3lX/wOGdR12+ZnlhMUYuWInr396I+z/Zgevf3uiX88rdewY7f8KX9wzWcByFBvN5SI4CWufDG/Z5wjkPfAalJg6A89oT7tYMsfvw9qE4cKYaxypqnRb5ami0odffvw+rXg1PJWhjUN1iBV5Hbr2kCy7vmyWpd8Dd3VSg7rYa6hswZ/Kz2LV6L1KykvGv9c8io0sHh+0LVk0TOyn1Yrxd0DBQ72l/vbueKn+2mYIjFOcjRS9P6nzItucDcJ/sdrqqTtJ+bn53M57+dh/+s+EYnv52Hy74+/eY/93e5uetNhFPLi2M6MADgNvAAwDeX39MUu+AlLupSflZWDd7LD6+YxheuW4APr5jGNbNHuvzBb+pB+RhdO2bg4riSjw65VkYK6pbbROqJMpQ5E/4+p6B6qmi0GM+D8mVrIMPwPUfx44TlV7v9801RZj/3d7mbvmPNp+Q9DqVQnA6IyaSFLvokvXkwi51yMtT8Uk6PPvdo0jrmILj+07hzb/+p9XzofrQDUX+hD/ec1J+VtMU8jYJyY6Ssyl8MJ+H5Eq2CadtOfrjsPl41/rmmiIIKPKoxyMnJQ5Hykw+vW+4EOG44qknF3ZfipW5k56Thsc+eRAPjpqLn/6zGtf+bQa69OkEIHQfuqHIn/DXe07Kz8KEvExWOI0gzOchuZJ9z4edoz8Of/SYe7qL7ESN728aIkovftuOegfkdDeVP6I3RswcAptNxHuPfdT8eKg+dD2vFyOv9wxUTxWFRijORyIpZB98uPrjOFJqDHp7Nh4N37HRlDi1V68rMbTOrZHb3dRtz94AhULAr19twZ71+wGE7kM3FPkTzNkgZ3hukFzJPvgQ4fyPY19JdfsXBFijLehv6TedkmO9el1pdeuCat5e2ANV5KhLn04Yd9NoAMDqz9YDCO2HbijyJ5izQc7w3CA5CpucD0fqLGEcCYSA2eLdQnb7TrfvYbpuSA5e+ulgu8edXdgDXeQou3smAKCh/nzBOfuHbtv3dbaSrj+FIn+CORvkDM8NkhvZBx+ulnnn341n9pbUePW6orLzPUzLC4vxxNeFOFPd4HBbRxd2Z/U27NNy/XH3pYxRAgCsltbTiUP5oWvPnwimULwnhQeeGyQnsg8+XM2ciNfEwFzrvnZFpFErgIYgdvrsP1MNq03Eir0l+PPiAqfbPTj+Atw7tkerC7u7abmugktPxKjOBR/W9geGH7pERPIi+5wPO0czJ9LDZFl7fwtm4AEA9Y3AxsPleOgz14u5vbnmcLvHglVvo6aqafqzWutdUi0REQVP2AQfjmZOKBVh0/ywt/ZQKWobXOeM1DZYsf5gWavHgjUt99i+kwCAzn06+rQfIiIKvLC4eisEYHCX5HaPd031bvYGeW73SWnTmr/YfrLV98GalntsT1OF2q59c3zaDxERBV5YBB82Edh2rH0pdT8vy0FOqBVAnEYpadvaBmurKbU2m4jMxMDW22i0NOL0oRIAQKde2V7vh4iIgkP2Cad2jrrltx0L34Jf4SRVp8bQrqlYsbfU7bYJWmW7VTST4lTNyaUt40V/1dtQKBWIT46HsbwapcfOIj0nzet9ERFR4IVFzwfguFveZPaubgV5RqdVYdYlXSVt+0XB6XYJpobac7U3HFT7+uOoXJ+n2SoUCgwclw8A2LZil0/7otAIVAE6IpIn2fd8CGiqHeGoW17k51NQqJQClAoBOrUSJhdJp217Nuzsj7X9fYki8PbaIigEYM6UPJ/aOHhCf6z+bAO2LN+Om+Ze3Vz3w9+sNpGFmvws0AXoiEh+ZB98uCqvnqKLganKcbEr8h9Low2biypcBh6A54v02b25pgj9OyVjyoXeX2gGT7gQALB/y2Hc3P0eTL1zAnoM6ApRbKr9ceBMNapqG6BttCIVVlSXV8NQVg1juREN5kZAFCGKIkQREARg0LgLMfMvk6FSq5rfgxdJ/wtGAToikh/ZBx+uuLkWkp9UmCwoMQZ2hdq5Xxfi8nzvC42ld+6Av7z2R7z/+Kc4e6Ic78/9xKf2bP1hJ75/52fcu/CPGDSuHy+SARCsAnREJD+yDz5cfQCJHHcJCmO9BWVtFpfzt3JTg8Mqtp6YdtfluPy2MVjz+Uas+HA1Tp2qxLGKWgACRAGAIMCmVsEap4U1VoMrhnfD4LxsqLUqCELTuSUIAozl1fhkwVc4sf80Zk94Cpf+/hJ817U7RLQfyuFF0nueFKBjhVqiyCL74MPVB5BKqQRgcfg68p9GEdh0pMz9hj7ytdAY0FThdPxNozH6upEY9PQK1Jidl9//XBODR/84HuqY9nnXl982Bu/P/QTLFv2A1Z+uh1a9BbopI2G6oEu7bXmR9E6wCtARkfyEzWwXRx9A2cmaELQkOv3021nJ23p77+9roTG75YXFuPg514EHANSYG3HxcyuwvLC43XPxSTrc++ofsHDz80jslAplgwVJ239zuT9eJD0TrAJ0RCQ/YRN8OPoAqmvgsIvcTMrPQKa+9e9KH+u+g83XQmN29tyMSokLDlbWNuKuxQUOAxAAyMxNR4OhFgBg7NfT5b54kfTM0NwUZOkDW4COiORJ9sMurqbakvz06JCA124Y3G466gvL9+HNNUUOXyPA90JjgOsERnec5Wz8759LUV9dB2tGCmr65Dp8Lc9R7ygVAp6Yloe7FhcErAAdEcmTrHs+3H0A9euoD26DyK3h3VObl7CfMaBj8/dzpuTh9RsGIUXXetXZLL3WbzNF3CUwOuNsZd2TB05jySvfAQCuevQqQBAc1UkDwIuktyblZ2HRTYPa9ZZl+vG8ICL5kXXPR6abGgqdU+OC3CJyx1DrvO7KlAuzcHl+ZsCKdPmac9Hy9aXHz+LhCU+hvtaMviN64Z57J6LHnpJ2dT7cnaPk3qT8LEzIC9x5QUTyI9vg491ZQzDmwi4uP4BOVzHBT27u/mg73lAITi/G9l6RQPA158L++sozVXh4wtM4e6IcOb2y8cQXf4MgCLxIBlAgzwsikh/ZBh9Du7n/UGedD3kKdM0LZyXO7QmMJYZ6j/I+WuZsmAwmPDLpGZw6WIyMLh3w/I9zkZx+fniPF0kiIt/JNviQIl4bmPU7yDeBrHnhrsS5PYHRU09My0N9TR3+Pu15HNl5DCmZSViwYi5XyCUiCgBZJ5y6oxDCuvkRzdv8C1erm9qn0bZNKrWXOF9eWNycwJiiU7XdtUMpOhUW3TQIIzsl4pHLn0Hhut+g08fhmW/moGMP5nEQEQVCWPd8JMep3W9EIeFN/oWrXo0JeZmS1wGZlJ+FOosND366w+17zr2iLy7JisfD4+fhYEERElLi8fwPf0fPQd08bj8REUkT1l0HaQmscCpXK38749H27no1Fq48JHkdEADITJQW/CRYLPjbuKbAI6lDIv7x8xO4YHB3j9pORESeCe/gQ8eeD7l6Z10RGhptkrZ1t7qpCOC99Y4LlLVlH+6RVD1TI+Dzu17HkV1NOR7/XPUkuvfvKul9iIjIe2EdfPxWYgx1E8gJmwh8uOGopG2lFAerqpW2gKB9uMdePRNwstaMpRGdv1qFw9ubejz+uepJdMnLkfQeRETkm7AOPpqWSye5kvr7KTFKS051t0ZM23VAnFXPhM2GzGWrUbH7KESNGlcs/BNyenWU1AYiIvKdbIOPzUcqWs10cIhlPmStS4q0CrQVNWZJ2+VlJrp8fnr/rHa1RSblZ2Hd7LF4cPy5ReFEEek/bED8oROwKRU4deVYPLntrNOF5YiIyP9kG3zc/sEWjFyw0uVFIVErbTol+WbmgGyPX6MQgJuHd5W0bdv1XpzZW1Lt8vmlO4udBqyfbDkBAEjYcxj63QchCgJKpl+Gus6ZAJpmyrgNdomIyC9kG3wAres3OMIyH8HRMTnW49fcMSoX6hhpv6BMvbT9G+pc5304WhwOOJ9Toqo0In3FRgBA+cgBMPXsDMD5wnJERBQYsr5822c6OLsrZc9HcCTFql3OHGlJIQB/Gp2LOVOakj1dFQ2zs89Mcd0Gab9rR8XNSqvrAasVmctWQ2FpRG1OBiov7ifptURE5H+yDj7snN2VVtU5X0GV/CctXu165kgLHeLVGNg5GUBT7Y6RC1bi+rc34v5PduD6tzc6HEqzz0xxNS12VE9ppdodFTdLT9AiecseaEvKYdWqcWbqaEDR/tT3dWE6IiKSJiyCD8DxjIhirmobFJn6WOczR9oorW7AXYsLMP+7vW5Lobdk33/bHpAsvRZ3js7Fsl0lLt9XQPvZLnb5abFI3bIHAHB27FA0Juokv5aIiPwvbMqrO5oRYbVJK2JF3kuKUzVflO1Lym88Uo57/luAKgc5GPZBlbfXFkkqhd5ydoqjJesHd0nGpf9YJamtT0zLc7iS7vJ//wyhzoyG5ETU5LUumy64eS0REflf2AQfjmZElNdw2CXQ2l6OlQoBCkFwGHi05GriSMsEz7Yr37Zdsn7D4XK3BcgA4IHxF2BSfvuF4BrqG/D5i8sAANMevAJfKONa7S+zxYq4REQUHGETfDiaEVEmsT4Eea+y1tIuSPBXYqaU/Uh9r65pjmuK/PDeKlQUV6JDTiruf/gKPBgT06pnZWhuCns8iIiCzO85H42Njfj73/+O3NxcxMbGolu3bnjqqadg82GIxNl4fAJnuwRF23ybNJ1/FvSTkuApNQm0rNrcbkZNg9mCj59fAgC49m8zoFKrmntWZgzoiOHdUxl4EBGFgN97PhYsWIA33ngDH3zwAfr27YutW7fitttug16vx/333+/x/gQ4H4+f2DcD245X+d5ocqms+nwP0/LCYjy5dK/b1ygEQBQdF6EV0DTcISXB0z4Nt8RQ77SgrUIAnv52X/P3WeeGUizrduPsiXKkZidjyh/HuX0vIiIKDr/3fGzYsAEzZszA1KlT0bVrV1x99dWYOHEitm7d6vG+svRaLLppkNPx+NtGdHP4eCBF431yZW1Tbo192Xt3a7EIaCoyZv//ts8B0hM83S4Qh/b5JSWGetz1wRa89/TnAIDrHrkSai1XQCYikgu/Bx8jR47Ezz//jAMHDgAAdu7ciXXr1mHKlCkOtzebzTAaja2+AODdWUOwbvZYl4mASoUAlTK44YBKGdS3kwWF4HrZ+7bG56VjzpQ8h1NzM90ElI44m+brLHYRAaT8ugPVxZVIyWKvBxGR3Ph92GX27NkwGAzo3bs3lEolrFYrnn32WVx//fUOt58/fz7mzZvX7vGh3dwnAq4/VAaLNbjrcTRYg/p2sjC8W5qkZe/tVuwtxXe7ijHlwvZTZ1smeFptouTkz7bTcMuqza2GWlrSni5F8sbdAIAJj17DXg8iIpnxe/Dx6aefYvHixfjoo4/Qt29f7NixAw888ACys7Mxa9asdtvPmTMHDz30UPP3RqMROTk5kt7ry4KTfms3OZYUp8Kw7qn4Ztdpj1439+tCXJ6f2W7qrJ09d6TlEE5mohZPTnc+7bXlvr7eccrxG4siOvy8GQIAY9/u6DAiz6N2ExFR4Pk9+Pjb3/6GRx55BNdddx0AoF+/fjh27Bjmz5/vMPjQaDTQaLybPWGKxm6IIHv+qn5QKgSPS4+Xmxoc1vEAmgKPPy8uaPd4ibEef15cgDckDMs4a09C4SFoi8tgVatQdulglkwnIpIhv+d81NbWQtFm3QylUunTVFtnhnRN9vs+XYnGZFM7KYu/tfV9YXG7xeSsNhGPfLnb5evmfLnb7fL29va0/J2oyyqR/tMmAEDl8AuR3jGFJdOJiGTI78HHtGnT8Oyzz+Lbb7/F0aNHsWTJErz44ou48sor/f1WmHVJblADgtduGOjxBTic2cugW22i28XfHPnPhmPtFpPbeKQcVbWuq6NW1lqw8Ui5y23azoJRmBuQtWRV06q1XbJQNaSvX0umS1mdl4iIpPF78PHqq6/i6quvxt13340+ffrgr3/9K/70pz/h6aef9vdbQR2jwJ2jc/2+X2eW7DjVfMGLBi3LoAPnZ50kxXlW3K3lYnIbDrsOKuykbNc8CyZBg4xv10JdaYQlQQfbjROx6JaL/FYyXerqvEREJI3fg4+EhAS8/PLLOHbsGOrq6nD48GE888wzUKsDM+NgzpQ8/Gl0cHpAVuwtxaUXpGNokId7Qq1lifNJ+VnY9vcJmHZhpuTXi+e+mqbqSu0xkLbdpPws/KmhHPGHTkChUuLe9+/Duqem+jXw8GR1XiIics/vwUcozJmSh/3PTMbcqX1wy/AumDu1D3Y+PjEg7/Xcd3sxJMryCByVU++RnujxfooN9UiKldZrMrxbmqTtVn60Fv89V0zsgdfvwNVXDvbrUIuz2ib2x+zDUkREJF3YLCznjjpGgT+Mal3xdEJeOlbsLfXr+xwtr8Wdo7rhtVWH/bpfWWtxLW+aIrsHJUbvFvVL0WkQp1ai1sVMJZ1aiWEOZsm0dWDbYfzfHxcBAK6bPROT/+DfYmLuapu4Wp2XiIici4ieD2fevmUIJuSlO3yuewfHq6C60zU1Do1W/8/ckbPSc2u72KfIeht4AECFqQHqGNenncrN8wBQWWrAk1f9Aw31Flw8dRBufeY6r9vkjNQVdf21yi8RUbSI6OADaApA9j01CTcP64xRPdNw87DO2PfUJEzsKz1noaVHp+Th3+uK/NxKeauoMUuaIitFZa3Z7WyXqlpLc5KrI3U1dXh8+vM4e6IcnS7IwiMf/gVKpf/r3kutEcJaIkREnomYYRdXYtVKPD2zX6vHSqo8v1udkJeOWLUSpw11/mpaWEjRqbFw5SG3QYMUCkFavOusN6HBbMGTv/snftt8CAkp8Zj31WzEJ+l8bpcj7lbU9WR1XiIiOi/iez6cyU6K9Wj7CXnpePuWIQCArMToutNNT9DivV997+0RAFws8ULtqDfBarViwS2vomDFLmh1Gjz33aPo3Lujz+1yxtWKup6uzktEROdFbfBxSXdpsynG9+mAfU9Nag48AOBPo7oHqlmyk6XXAgJQVed7r4d47j9tK5O2JJx7z7a9CaIo4rW/vIc1/9uAGJUST375N/Qe2tPnNrnjbEVdb1bnJSKiJlEx7OLIsO6pSIpTuRxKSIpT4c2bh7S7sx3ZqwPUMQo0NEZ+4un0/lkoq/E+wbStTUfL8cS0PNy1uAACWlfzcNabIIoi3n74Qyxb9AMEQcAjH/4Fgyf091ub3Gm7oq67FXiJiMi1qO35UCoEPH9VP5fb2BdVc/Taf103IEAtk5elO4sd1vnwlk30rDdBFEW89/eP8b//WwYAuH/RHbj02kv81h6p7CvqzhjQEcO7pzLwICLyQdT2fABNF8E3bhrUrm5FZqIGT07v67JL3f7auUt24ayp0aP3bXvHL2fFhnpAaEo6rTA1+Ly/5LimSrdSexMWP/05Pp6/BABwz79ux9Q7J/jcBiIiCq2oDj4A37rUJ+VnIUGrwo3/3uTRe2bqtRiQk4TvC0u8bbZXvA16ymrMeGpaX9z7yXaf25CWcL4Xxd6b4IjNZsN/nvgM/332CwDAn/9vFmbeO9nn9yciotCL2mEXf/EmH0IURfTKiA9Aa1y7qEuSV69LT9AiNcE/Qy+ZEmYK1Znq8czvX2wOPP4w/0b87sEr/PL+REQUelHf87G8sBjzlu1tVUY7S6/FE9PyJM1k8KbA1BmjGS//fAg6tRImF2XG/W1c7wxsOVYlefuWdSy+2XXa5/fPTNTAJor4escppz1MZ46dxeMzF+DIzmNQqWPwl0V3YtJtY3x+byIiko+oDj7sK5a2HYqwr1gqZSrl4C7JUAhNiZRSiWhfNyIYqhuk56a0nXnijyqe1fWNrYaoUnRqPDMjH1MubDrGhb/+hnlX/QNVZ41IStfjyS//hr6X9PL5fYmISF6iNvhwt2KpgKYVSyfkZbrM/9h2rNKjwKPlewSz1wPwLODJbNP7Y6/26WqhNXfa/rwVpgbc/VEB/ni4Ezpt34dPnv8K1kYruvXvgqe/no30zh28fi8iIpKvqM358GTFUlfCZVGxLL1W8jL1c6f2wbrZY1v1+igVAqb393NBLVGE7uBx/HT7y/jvM1/A2mjFpdcOx8vrnmHgQUQUwWTb8yGKgZ2M6q8VS+W+qFjL4ZMhuSluh4gEABdkJLR73GoTsXRnsd/apaowosPKTdAdOdW0/0QdHn/7T7j06mEQBNbQICKKZLINPmb1uBf9LumLvsN7YeiUQcjt19mvFyV/rVjqbvGxQHhwfE98suVEq56bpDgVRvZIw9ajlSgxnn+85fDJhsPlboeIRAA3v7u5XdKtu54iqRT1ZiRvLkTSlj1QWG0QFQpUDu2LimEXQjPoAgYeRERRQLbBh6GsGhuXbcPGZdvwzqMfIbtHJoZNHYwhkwfiwtF9oNaqfdq/v1YstS8+5qhcuDP2y6s+TgVDrUVy0GJv071je+LesT0d1iax2kSnNUs8GSJqm3Tr6/CS0lSHpK17od/+G5QNTSXtTbnZODvuYlhS9B63j4iIwpdsg48FK+bixO5i7Fy9B9t+3InTh0rw5Svf4stXvoU2ToP+Y/piyKSBGDCmLzr36eTxHbOroMHTFUvt5cIdTdmd3j8LS3cWt3rc3hsBQHLQ4qhNjgp0uSrc5ckQUdukW09e2/LniTGakLy5EIm7DkDR2JRwak5LQvmogTD16Ay0+L3JfQiLiIj8QxADnVzhIaPRCL1eD4PBgMTERABAXU0dtv6wE5u/344ty7ej/HRlq9ckpiYgf2Rv5I/sg/yRvdFzUC5iVNLiKl/rfLTkrNfBVW+Eo/dPilMBQKtF77xtU9v2jVyw0uMhoo/vGIbBXZLRe+73LodtFALwr98PwLPf7IVxx2Ek7j4I3eETEM69qD4zDRXDL4SpR06roANo+vnWzR7LNVOIiMKUo+u3M2ERfLQkiiKO7DqGLd9vx7YVO7Fv40GY61qvOaKJVeOCId0x/IqLcNl1I9Chk+OeADtXwUEwOHp/AAFpk722CSC91Por1w1AeoIW17+90eV2qkojblbWYs/Xm1BRfD5A7Dc6D8oJF+F/RqFd0AE09ZRweXoiovAW0cFHW5YGCw4WFKFw7T7sXrcPe9b9hupKU/PzgiAgf1RvjLzyYlwyYwgyu6YHsvlhwVFviysf3zEMpdX1uP+THe2eU5UbEH/wGOIPHIO2pLz5cX1aAsbfNBqX3z4WufmdAQDf7TqNv39diAqTf3t0iIgo9KIq+GjLZrPhxP7T2LGyEKs/W4/da/e1ej63X2dcMn0Ihk+/CD0G5UKpVPqr6WHFahOx8XA57vmoAFV1Fofb2BNc180ei81FFbj+7Y0QGizQFp9F3PES6A4eh6asqnl7EUCPkXm44S+TMHz6RVCpVQ7fN5S9TEREFBhRHXy0VXr8LNZ+sQnrl25B4dp9sLVIWohLjEXfS3qh74jeyB/ZG72G9IA2zj8LqIULZ8MwAgBYbXh2dA46N5pRuO43fPa/zVCcPtucwwEAokJAbZcsmHp2gW5wT6x9+goGE0REUYjBh7N9l1dj8/fbsX7pFmz7YSdqq+taPa+MUaLn4G7oN7I38kc1Ja8mprQvuBUKDWYLTFUmmOsa0FBvQUN9078WswXKGCVU6hioNCrEqGOgUsdAE6eGVqeFJk7tsnenvtaMr1bvx6tf7YLhjAExNSZoSiuhK6uEqqwStkZbu9dYEnSo65SB2m4dYereCaK2KWBj3gYRUfRi8CGB1WpF0e7jKFz3G/b8+ht2r93XbhYNAHTtm4OcPh2RlZuBrG4ZyOqWjoyu6UhMiUdsgtbh0ILT92y0or7WDFOVCTVVtaiurIHp3L/G8hoYy6thLDPCWNH0/9UVNaipNKG6ogb1tWavf1a1VgWtTgtBAGw2EaJNhM1mg63R5na/2jgNOl6QhV4XdUf+qD6ozEjDS9tK/DI7iIiIIgeDDy+IooiSo6UoXPcbdq/Zh8J1+3Biv/tl5FUaFXSJsdDGa6FoM9xgs4loqLfAXGuGudaMRovvC8lpYtVQa1VQac/9q46B1WpDY0MjLGbLuX8bYa5rkFyiXhOrRkpWMlKykpCSlYwufTqh56Bu6D6gKzrkpEKhaL0EEPM2iIioLQYfflJZasBvmw6i+PAZFBedQUlRKYqPnMGZo2d96olQqWMQn6xDfJIOuiQd4pPikJia4OArHvHJ8UhI1iEhJR46fVy7QMAZURRhrmtAvake9SYz6k1N7VUoFVAoBAgKAQqFAolpCYhLiGVZcyIi8okn12/ZVjiVg+R0PYZPu8jhc42WRtTV1KPWWIdaYy3qaurRMowThKb/qLUqaOM00MRpmvIw4jRQaVQBv9gLggBtnKYpgZYLxBIRkYww+PBSjCoGCcnxSEiOD3VTiIiIwoq0PnwiIiIiP2HPR5hj8icREYUbBh9hzJ+L4hEREQULh13ClL0yadv1WUoM9bhrcQGWFxaHqGVERESuMfgIQ1abiHnL9jpcldb+2Lxle2G1yWoWNREREQAZDrvYy44YjcYQt0S+Nh+pwKnSCpfbnCqtxapdxzC0W0qQWkVERNHMft2WUj5MdkXGjhw5gu7du4e6GUREROSFEydOoFOnTi63kV3PR0pK05368ePHodfrQ9waeTMajcjJycGJEydCXg1W7nispOFxko7HShoeJ+nC/ViJoojq6mpkZ2e73VZ2wYe9fLherw/Lgx8KiYmJPFYS8VhJw+MkHY+VNDxO0oXzsZLaacCEUyIiIgoqBh9EREQUVLILPjQaDZ544gloNJpQN0X2eKyk47GShsdJOh4raXicpIumYyW72S5EREQU2WTX80FERESRjcEHERERBRWDDyIiIgoqBh9EREQUVCEJPl5//XXk5uZCq9Vi8ODBWLt2rcvtV69ejcGDB0Or1aJbt2544403gtTS0PPkWP3yyy8QBKHd12+//RbEFgffmjVrMG3aNGRnZ0MQBHz11VduXxOt55Snxypaz6n58+djyJAhSEhIQHp6OmbOnIn9+/e7fV20nVfeHKdoPacWLVqECy+8sLmA2PDhw/H999+7fE0kn09BDz4+/fRTPPDAA3jsscewfft2jBo1CpMnT8bx48cdbl9UVIQpU6Zg1KhR2L59Ox599FH85S9/wRdffBHklgefp8fKbv/+/SguLm7+6tmzZ5BaHBomkwn9+/fHwoULJW0fzeeUp8fKLtrOqdWrV+Oee+7Bxo0bsWLFCjQ2NmLixIkwmUxOXxON55U3x8ku2s6pTp064fnnn8fWrVuxdetWjB07FjNmzMCePXscbh/x55MYZEOHDhX//Oc/t3qsd+/e4iOPPOJw+4cffljs3bt3q8f+9Kc/icOGDQtYG+XC02O1atUqEYBYWVkZhNbJEwBxyZIlLreJ5nOqJSnHiudUk9LSUhGAuHr1aqfb8LySdpx4Tp2XnJws/vvf/3b4XKSfT0Ht+WhoaMC2bdswceLEVo9PnDgR69evd/iaDRs2tNv+8ssvx9atW2GxWALW1lDz5ljZDRw4EFlZWRg3bhxWrVoVyGaGpWg9p3wR7eeUwWAAcH7hS0d4Xkk7TnbRfE5ZrVZ88sknMJlMGD58uMNtIv18CmrwUVZWBqvVioyMjFaPZ2RkoKSkxOFrSkpKHG7f2NiIsrKygLU11Lw5VllZWXjrrbfwxRdf4Msvv0SvXr0wbtw4rFmzJhhNDhvRek55g+dU00qdDz30EEaOHIn8/Hyn20X7eSX1OEXzObV7927Ex8dDo9Hgz3/+M5YsWYK8vDyH20b6+RSSVW0FQWj1vSiK7R5zt72jxyORJ8eqV69e6NWrV/P3w4cPx4kTJ/DPf/4To0ePDmg7w000n1Oe4DkF3Hvvvdi1axfWrVvndttoPq+kHqdoPqd69eqFHTt2oKqqCl988QVmzZqF1atXOw1AIvl8CmrPR1paGpRKZbs799LS0nYRnl1mZqbD7WNiYpCamhqwtoaaN8fKkWHDhuHgwYP+bl5Yi9Zzyl+i6Zy67777sHTpUqxatQqdOnVyuW00n1eeHCdHouWcUqvV6NGjBy666CLMnz8f/fv3xyuvvOJw20g/n4IafKjVagwePBgrVqxo9fiKFStwySWXOHzN8OHD223/448/4qKLLoJKpQpYW0PNm2PlyPbt25GVleXv5oW1aD2n/CUazilRFHHvvffiyy+/xMqVK5Gbm+v2NdF4XnlznByJhnPKEVEUYTabHT4X8edTsDNcP/nkE1GlUonvvPOOuHfvXvGBBx4QdTqdePToUVEURfGRRx4Rb7755ubtjxw5IsbFxYkPPviguHfvXvGdd94RVSqV+Pnnnwe76UHn6bF66aWXxCVLlogHDhwQCwsLxUceeUQEIH7xxReh+hGCorq6Wty+fbu4fft2EYD44osvitu3bxePHTsmiiLPqZY8PVbRek7dddddol6vF3/55RexuLi4+au2trZ5G55X3h2naD2n5syZI65Zs0YsKioSd+3aJT766KOiQqEQf/zxR1EUo+98CnrwIYqi+Nprr4ldunQR1Wq1OGjQoFbTsmbNmiVeeumlrbb/5ZdfxIEDB4pqtVrs2rWruGjRoiC3OHQ8OVYLFiwQu3fvLmq1WjE5OVkcOXKk+O2334ag1cFln7rX9mvWrFmiKPKcasnTYxWt55SjYwRAfO+995q34Xnl3XGK1nPq9ttvb/4s79Chgzhu3LjmwEMUo+98EkTxXAYLERERURBwbRciIiIKKgYfREREFFQMPoiIiCioGHwQERFRUDH4ICIioqBi8EFERERBxeCDiIiIgorBBxEREQUVgw8iIiIKKgYfREREFFQMPoiIiCioGHwQERFRUP1/KL5ipJKLsj4AAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.scatter(x, y)\n",
+    "ax.contour(X, Y, Z, levels=[level])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "id": "329c38f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    "data_kde = data[cond_kde]\n",
+    "data_inl = data_kde.copy()\n",
+    "\n",
+    "for k in range(11):\n",
+    "    shgg_params = estimate_sso_params(\n",
+    "        data_inl[\"mred\"],\n",
+    "        data_inl[\"dm\"],\n",
+    "        np.radians(data_inl[\"SOE\"]),\n",
+    "        data_inl[\"filt\"],\n",
+    "        np.radians(data_inl[\"ra\"]),\n",
+    "        np.radians(data_inl[\"dec\"]),\n",
+    "        model=\"SHG1G2\",\n",
+    "    )\n",
+    "    fw_model = np.zeros(len(data_inl))\n",
+    "\n",
+    "    for ff in np.unique(data_inl[\"filt\"]):\n",
+    "        mask = data_inl[\"filt\"] == ff\n",
+    "\n",
+    "        pts = func_shg1g2(\n",
+    "            [\n",
+    "                np.radians(data_inl.loc[mask, \"SOE\"]),\n",
+    "                np.radians(data_inl.loc[mask, \"ra\"]),\n",
+    "                np.radians(data_inl.loc[mask, \"dec\"]),\n",
+    "            ],\n",
+    "            shgg_params[f\"H_{ff}\"],\n",
+    "            shgg_params[f\"G1_{ff}\"],\n",
+    "            shgg_params[f\"G2_{ff}\"],\n",
+    "            shgg_params[\"R\"],\n",
+    "            np.radians(shgg_params[\"alpha0\"]),\n",
+    "            np.radians(shgg_params[\"delta0\"]),\n",
+    "        )\n",
+    "        fw_model[mask] = pts\n",
+    "\n",
+    "    residuals = fw_model - data_inl[\"mred\"]\n",
+    "\n",
+    "    threshold = 3 * np.std(residuals)\n",
+    "    cutoff = np.abs(residuals) <= threshold\n",
+    "    \n",
+    "    prev_len = len(data_inl)\n",
+    "    data_inl = data_inl[cutoff]\n",
+    "    new_len = len(data_inl)\n",
+    "\n",
+    "    if prev_len == new_len:\n",
+    "        print(k)\n",
+    "        break\n",
+    "\n",
+    "data_inl = data_inl[cutoff]    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "id": "387106df",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x77cd07b689d0>"
+      ]
+     },
+     "execution_count": 109,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.scatter(data[\"SOE\"], data[\"mred\"], label=\"Original set\")\n",
+    "ax.scatter(data_kde[\"SOE\"], data_kde[\"mred\"], label=\"KDE on dxy\", marker=\"P\")\n",
+    "ax.scatter(data_inl[\"SOE\"], data_inl[\"mred\"], label=\"sHG1G2 iterations\", marker=\"*\")\n",
+    "ax.invert_yaxis()\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "id": "2346ad21",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Querying ephemerides via IMCCE Miriade..\n"
+     ]
+    }
+   ],
+   "source": [
+    "import rocks\n",
+    "rockid = str(rocks.Rock(kast).number)\n",
+    "\n",
+    "c_AU_day = 173.14463267424034  # c in AU/day\n",
+    "\n",
+    "data_inl[\"JD_lc\"] = data_inl[\"MJD_lc\"] + 2400000.5\n",
+    "\n",
+    "print(\"Querying ephemerides via IMCCE Miriade..\")\n",
+    "ephem = query(rockid, data_inl[\"JD_lc\"])\n",
+    "\n",
+    "ra_s = ephem[\"RA_h\"].values\n",
+    "dec_s = ephem[\"DEC_h\"].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "id": "f3b1e098",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = data_inl.reset_index(drop=True)\n",
+    "\n",
+    "# Rename columns to match Fink format\n",
+    "pdf.rename(\n",
+    "    columns={\n",
+    "        \"SOE\": \"Phase\",\n",
+    "        \"dm\": \"csigmapsf\",\n",
+    "        \"filt\": \"cfid\",\n",
+    "        \"mred\": \"cmred\",\n",
+    "        \"R\":\"Dhelio\"\n",
+    "    },\n",
+    "    inplace=True,\n",
+    ")\n",
+    "\n",
+    "# Add missing columns\n",
+    "\n",
+    "pdf[\"residuals\"] = 0.0\n",
+    "pdf[\"ra_s\"] = ra_s\n",
+    "pdf[\"dec_s\"] = dec_s\n",
+    "\n",
+    "# LT correction\n",
+    "pdf[\"cjd\"] = pdf[\"MJD_lc\"] + 2400000.5  # MJD to JD\n",
+    "\n",
+    "cfid_map = {\"o\": 1, \"c\": 2,}\n",
+    "pdf[\"cfid\"] = pdf[\"cfid\"].map(cfid_map)\n",
+    "\n",
+    "# Make it readable by asteroid_spinprops\n",
+    "pdf_s = pd.DataFrame(\n",
+    "    {col: [np.array(pdf[col])] for col in pdf.columns}\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "id": "344968e0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
+      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from asteroid_spinprops.ssolib import modelfit\n",
+    "\n",
+    "base_kwargs = dict(\n",
+    "    use_angles=True,\n",
+    "    use_filter_dependent=True,\n",
+    "    use_phase=True,\n",
+    "    use_shape=True,\n",
+    ")\n",
+    "\n",
+    "current_kwargs = base_kwargs.copy()\n",
+    "\n",
+    "SOCCA_params = modelfit.get_fit_params(\n",
+    "    data=pdf_s,\n",
+    "    flavor=\"SOCCA\",\n",
+    "    shg1g2_constrained=True,\n",
+    "    period_blind=True,\n",
+    "    pole_blind=False,\n",
+    "    period_in=None,\n",
+    "    period_quality_flag=True,\n",
+    "    terminator=True,\n",
+    "    time_me=True,\n",
+    "    remap=True,\n",
+    "    remap_kwargs=current_kwargs,\n",
+    ")\n",
+    "\n",
+    "SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbcc4c56",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "socca",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From e4be58275fabda6f4225a5052bbf9e42b12ec6ad Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 12:09:12 +0200
Subject: [PATCH 02/14] debug period bounds

---
 fink_utils/sso/spins.py | 56 +++++++++++++++++++++++------------------
 1 file changed, 31 insertions(+), 25 deletions(-)

diff --git a/fink_utils/sso/spins.py b/fink_utils/sso/spins.py
index 2a36802..e4c0391 100644
--- a/fink_utils/sso/spins.py
+++ b/fink_utils/sso/spins.py
@@ -748,8 +748,8 @@ def build_bounds(
     """
     if bounds is None:
         bounds = (
-            [-3, GMIN, GMIN, 0, -np.pi / 2, 2.2 / 24.0, 1, 1, -np.pi / 2],
-            [30, GMAX, GMAX, 2 * np.pi, np.pi / 2, 1000, 5, 5, np.pi / 2],
+            [-3, GMIN, GMIN, 0, -np.pi / 2, 0.12 / 24, 1, 1, -np.pi / 2],
+            [30, GMAX, GMAX, 2 * np.pi, np.pi / 2, 2.4e5 / 24, 5, 5, np.pi / 2],
         )
         lower_bounds = np.array(bounds[0])
         upper_bounds = np.array(bounds[1])
@@ -768,8 +768,8 @@ def build_bounds(
 
     if use_angles:
         bounds = (
-            [-3, GMIN, GMIN, 2.2 / 24.0, -np.inf, -np.inf, -np.inf, 1, 1, -np.pi / 2],
-            [30, GMAX, GMAX, 1000, np.inf, np.inf, np.inf, 5, 5, np.pi / 2],
+            [-3, GMIN, GMIN, 0.12 / 24.0, -np.inf, -np.inf, -np.inf, 1, 1, -np.pi / 2],
+            [30, GMAX, GMAX, 2.4e5 / 24, np.inf, np.inf, np.inf, 5, 5, np.pi / 2],
         )
         lower_bounds = np.array(bounds[0])
         upper_bounds = np.array(bounds[1])
@@ -1406,12 +1406,14 @@ def build_eqs_for_spin_shape(
 
             myfunc = (
                 func_socca(
-                    np.vstack([
-                        ph[mask].tolist(),
-                        ra[mask].tolist(),
-                        dec[mask].tolist(),
-                        jd[mask].tolist(),
-                    ]),
+                    np.vstack(
+                        [
+                            ph[mask].tolist(),
+                            ra[mask].tolist(),
+                            dec[mask].tolist(),
+                            jd[mask].tolist(),
+                        ]
+                    ),
                     params_per_band[index][0],
                     params_per_band[index][1],
                     params_per_band[index][2],
@@ -1432,14 +1434,16 @@ def build_eqs_for_spin_shape(
 
             myfunc = (
                 func_socca_terminator(
-                    np.vstack([
-                        ph[mask].tolist(),
-                        ra[mask].tolist(),
-                        dec[mask].tolist(),
-                        jd[mask].tolist(),
-                        ra_s[mask].tolist(),
-                        dec_s[mask].tolist(),
-                    ]),
+                    np.vstack(
+                        [
+                            ph[mask].tolist(),
+                            ra[mask].tolist(),
+                            dec[mask].tolist(),
+                            jd[mask].tolist(),
+                            ra_s[mask].tolist(),
+                            dec_s[mask].tolist(),
+                        ]
+                    ),
                     params_per_band[index][0],
                     params_per_band[index][1],
                     params_per_band[index][2],
@@ -1917,13 +1921,15 @@ def fit_sfhg1g2(
         outdic = {"fit": 1, "status": -2}
         return outdic
 
-    pdf = pd.DataFrame({
-        "i:magpsf_red": magpsf_red,
-        "i:sigmapsf": sigmapsf,
-        "Phase": phase,
-        "i:jd": jds,
-        "i:fid": filters,
-    })
+    pdf = pd.DataFrame(
+        {
+            "i:magpsf_red": magpsf_red,
+            "i:sigmapsf": sigmapsf,
+            "Phase": phase,
+            "i:jd": jds,
+            "i:fid": filters,
+        }
+    )
     pdf = pdf.sort_values("i:jd")
 
     # Get oppositions

From 592afc0e0e40238a35a56f5f0171df88e0033d56 Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 12:40:31 +0200
Subject: [PATCH 03/14] debug period bounds

---
 fink_utils/sso/spins.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fink_utils/sso/spins.py b/fink_utils/sso/spins.py
index e4c0391..fd98f34 100644
--- a/fink_utils/sso/spins.py
+++ b/fink_utils/sso/spins.py
@@ -749,7 +749,7 @@ def build_bounds(
     if bounds is None:
         bounds = (
             [-3, GMIN, GMIN, 0, -np.pi / 2, 0.12 / 24, 1, 1, -np.pi / 2],
-            [30, GMAX, GMAX, 2 * np.pi, np.pi / 2, 2.4e5 / 24, 5, 5, np.pi / 2],
+            [30, GMAX, GMAX, 2 * np.pi, np.pi / 2, 4.8e5 / 24, 5, 5, np.pi / 2],
         )
         lower_bounds = np.array(bounds[0])
         upper_bounds = np.array(bounds[1])
@@ -769,7 +769,7 @@ def build_bounds(
     if use_angles:
         bounds = (
             [-3, GMIN, GMIN, 0.12 / 24.0, -np.inf, -np.inf, -np.inf, 1, 1, -np.pi / 2],
-            [30, GMAX, GMAX, 2.4e5 / 24, np.inf, np.inf, np.inf, 5, 5, np.pi / 2],
+            [30, GMAX, GMAX, 4.8e5 / 24, np.inf, np.inf, np.inf, 5, 5, np.pi / 2],
         )
         lower_bounds = np.array(bounds[0])
         upper_bounds = np.array(bounds[1])
@@ -2186,7 +2186,6 @@ def fit_spin(
             args=args,
         )
     except (RuntimeError, ValueError) as e:
-        print(e)
         outdic = {"fit": 3, "status": -2}
         return outdic
 

From 37a8b7131839a4dab7dcc7eb5cae238ba0789e1a Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 15:30:00 +0200
Subject: [PATCH 04/14] Add a photometric cleaning script

---
 fink_utils/sso/clean-fit-atlas.ipynb  | 543 --------------------------
 fink_utils/sso/cleaning-example.ipynb | 348 +++++++++++++++++
 fink_utils/sso/cleaning.py            | 169 ++++++++
 3 files changed, 517 insertions(+), 543 deletions(-)
 delete mode 100644 fink_utils/sso/clean-fit-atlas.ipynb
 create mode 100644 fink_utils/sso/cleaning-example.ipynb
 create mode 100644 fink_utils/sso/cleaning.py

diff --git a/fink_utils/sso/clean-fit-atlas.ipynb b/fink_utils/sso/clean-fit-atlas.ipynb
deleted file mode 100644
index 348dcb3..0000000
--- a/fink_utils/sso/clean-fit-atlas.ipynb
+++ /dev/null
@@ -1,543 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 102,
-   "id": "c4cd7a71",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pyarrow.dataset as ds\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "from fink_utils.sso.spins import estimate_sso_params, func_shg1g2\n",
-    "\n",
-    "from astropy.time import Time\n",
-    "import requests"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 103,
-   "id": "5a3443c9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def query(name, epochs):\n",
-    "    \"\"\"Gets asteoid ephemerides from VOSSP Miriade.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    name : str\n",
-    "        Name or designation of asteroid.\n",
-    "    epochs : list\n",
-    "        List of observation epochs in JD format.\n",
-    "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    pd.DataFrame - Input dataframe with ephemerides columns appended\n",
-    "                False - If query failed somehow\n",
-    "    \"\"\"\n",
-    "\n",
-    "    # Pass sorted list of epochs to speed up query\n",
-    "    # Have to convert them to JD\n",
-    "    epochs = [Time(str(e), format=\"jd\").jd for e in epochs]\n",
-    "    files = {\"epochs\": (\"epochs\", \"\\n\".join([\"%.6f\" % epoch for epoch in epochs]))}\n",
-    "\n",
-    "    # ------\n",
-    "    # Query Miriade for phase angles\n",
-    "    url = \"https://ssp.imcce.fr/webservices/miriade/api/ephemcc.php?\"\n",
-    "\n",
-    "    params = {\n",
-    "        \"-name\": f\"{name}\",\n",
-    "        \"-mime\": \"json\",\n",
-    "        \"-rplane\": \"1\",\n",
-    "        \"-tcoor\": 5,\n",
-    "        \"-output\": \"--jd\",\n",
-    "        \"-observer\": \"500\",\n",
-    "        \"-tscale\": \"UTC\",\n",
-    "    }\n",
-    "    params['-output'] += f\",--iofile(ephemcc-photom.xml)\"\n",
-    "\n",
-    "    # Execute query\n",
-    "    try:\n",
-    "        r = requests.post(url, params=params, files=files, timeout=50)\n",
-    "    except requests.exceptions.ReadTimeout:\n",
-    "        return False\n",
-    "    j = r.json()\n",
-    "\n",
-    "    # Read JSON response\n",
-    "    try:\n",
-    "        ephem = pd.DataFrame.from_dict(j[\"data\"])\n",
-    "    except KeyError:\n",
-    "        return False\n",
-    "    return ephem\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 104,
-   "id": "8f7fb7ec",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "kast = \"00045\"\n",
-    "\n",
-    "dataset = ds.dataset(\"atlas-sscat.v3.0\")\n",
-    "\n",
-    "table = dataset.to_table(filter=ds.field(\"kast\") == kast)\n",
-    "data = table.to_pandas()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 105,
-   "id": "eed89836",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data[\"dxy\"] = np.sqrt(data[\"dx\"]**2 + data[\"dy\"]**2)\n",
-    "data[\"mred\"] = data[\"m\"] - 5 * np.log10(data[\"R\"] * data[\"delta\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 106,
-   "id": "9edbfba8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from scipy.stats import gaussian_kde\n",
-    "\n",
-    "x = data[\"dxy\"].values\n",
-    "y = data[\"mred\"].values\n",
-    "\n",
-    "xy = np.vstack([x, y])\n",
-    "kde = gaussian_kde(xy)\n",
-    "\n",
-    "xmin, xmax = x.min(), x.max()\n",
-    "ymin, ymax = y.min(), y.max()\n",
-    "\n",
-    "X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]\n",
-    "positions = np.vstack([X.ravel(), Y.ravel()])\n",
-    "\n",
-    "Z = kde(positions).reshape(X.shape)\n",
-    "\n",
-    "Z_flat = Z.ravel()\n",
-    "idx = np.argsort(Z_flat)[::-1]\n",
-    "Z_sorted = Z_flat[idx]\n",
-    "\n",
-    "Z_cumsum = np.cumsum(Z_sorted)\n",
-    "Z_cumsum /= Z_cumsum[-1]\n",
-    "\n",
-    "threshold_index = np.searchsorted(Z_cumsum, 0.95)\n",
-    "level = Z_sorted[threshold_index]\n",
-    "\n",
-    "cond_kde = kde(xy) >= level"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 107,
-   "id": "29fdb953",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.contour.QuadContourSet at 0x77cd07ce8520>"
-      ]
-     },
-     "execution_count": 107,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots()\n",
-    "ax.scatter(x, y)\n",
-    "ax.contour(X, Y, Z, levels=[level])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 108,
-   "id": "329c38f7",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4\n"
-     ]
-    }
-   ],
-   "source": [
-    "data_kde = data[cond_kde]\n",
-    "data_inl = data_kde.copy()\n",
-    "\n",
-    "for k in range(11):\n",
-    "    shgg_params = estimate_sso_params(\n",
-    "        data_inl[\"mred\"],\n",
-    "        data_inl[\"dm\"],\n",
-    "        np.radians(data_inl[\"SOE\"]),\n",
-    "        data_inl[\"filt\"],\n",
-    "        np.radians(data_inl[\"ra\"]),\n",
-    "        np.radians(data_inl[\"dec\"]),\n",
-    "        model=\"SHG1G2\",\n",
-    "    )\n",
-    "    fw_model = np.zeros(len(data_inl))\n",
-    "\n",
-    "    for ff in np.unique(data_inl[\"filt\"]):\n",
-    "        mask = data_inl[\"filt\"] == ff\n",
-    "\n",
-    "        pts = func_shg1g2(\n",
-    "            [\n",
-    "                np.radians(data_inl.loc[mask, \"SOE\"]),\n",
-    "                np.radians(data_inl.loc[mask, \"ra\"]),\n",
-    "                np.radians(data_inl.loc[mask, \"dec\"]),\n",
-    "            ],\n",
-    "            shgg_params[f\"H_{ff}\"],\n",
-    "            shgg_params[f\"G1_{ff}\"],\n",
-    "            shgg_params[f\"G2_{ff}\"],\n",
-    "            shgg_params[\"R\"],\n",
-    "            np.radians(shgg_params[\"alpha0\"]),\n",
-    "            np.radians(shgg_params[\"delta0\"]),\n",
-    "        )\n",
-    "        fw_model[mask] = pts\n",
-    "\n",
-    "    residuals = fw_model - data_inl[\"mred\"]\n",
-    "\n",
-    "    threshold = 3 * np.std(residuals)\n",
-    "    cutoff = np.abs(residuals) <= threshold\n",
-    "    \n",
-    "    prev_len = len(data_inl)\n",
-    "    data_inl = data_inl[cutoff]\n",
-    "    new_len = len(data_inl)\n",
-    "\n",
-    "    if prev_len == new_len:\n",
-    "        print(k)\n",
-    "        break\n",
-    "\n",
-    "data_inl = data_inl[cutoff]    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 109,
-   "id": "387106df",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x77cd07b689d0>"
-      ]
-     },
-     "execution_count": 109,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots()\n",
-    "ax.scatter(data[\"SOE\"], data[\"mred\"], label=\"Original set\")\n",
-    "ax.scatter(data_kde[\"SOE\"], data_kde[\"mred\"], label=\"KDE on dxy\", marker=\"P\")\n",
-    "ax.scatter(data_inl[\"SOE\"], data_inl[\"mred\"], label=\"sHG1G2 iterations\", marker=\"*\")\n",
-    "ax.invert_yaxis()\n",
-    "ax.legend()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 110,
-   "id": "2346ad21",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Querying ephemerides via IMCCE Miriade..\n"
-     ]
-    }
-   ],
-   "source": [
-    "import rocks\n",
-    "rockid = str(rocks.Rock(kast).number)\n",
-    "\n",
-    "c_AU_day = 173.14463267424034  # c in AU/day\n",
-    "\n",
-    "data_inl[\"JD_lc\"] = data_inl[\"MJD_lc\"] + 2400000.5\n",
-    "\n",
-    "print(\"Querying ephemerides via IMCCE Miriade..\")\n",
-    "ephem = query(rockid, data_inl[\"JD_lc\"])\n",
-    "\n",
-    "ra_s = ephem[\"RA_h\"].values\n",
-    "dec_s = ephem[\"DEC_h\"].values"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 111,
-   "id": "f3b1e098",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pdf = data_inl.reset_index(drop=True)\n",
-    "\n",
-    "# Rename columns to match Fink format\n",
-    "pdf.rename(\n",
-    "    columns={\n",
-    "        \"SOE\": \"Phase\",\n",
-    "        \"dm\": \"csigmapsf\",\n",
-    "        \"filt\": \"cfid\",\n",
-    "        \"mred\": \"cmred\",\n",
-    "        \"R\":\"Dhelio\"\n",
-    "    },\n",
-    "    inplace=True,\n",
-    ")\n",
-    "\n",
-    "# Add missing columns\n",
-    "\n",
-    "pdf[\"residuals\"] = 0.0\n",
-    "pdf[\"ra_s\"] = ra_s\n",
-    "pdf[\"dec_s\"] = dec_s\n",
-    "\n",
-    "# LT correction\n",
-    "pdf[\"cjd\"] = pdf[\"MJD_lc\"] + 2400000.5  # MJD to JD\n",
-    "\n",
-    "cfid_map = {\"o\": 1, \"c\": 2,}\n",
-    "pdf[\"cfid\"] = pdf[\"cfid\"].map(cfid_map)\n",
-    "\n",
-    "# Make it readable by asteroid_spinprops\n",
-    "pdf_s = pd.DataFrame(\n",
-    "    {col: [np.array(pdf[col])] for col in pdf.columns}\n",
-    ")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 112,
-   "id": "344968e0",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n",
-      "FINUFFT_PLAN_T warning: using opts.nthreads=16, more than the 12 physically cores available; note large nthreads can be slower.\n"
-     ]
-    }
-   ],
-   "source": [
-    "from asteroid_spinprops.ssolib import modelfit\n",
-    "\n",
-    "base_kwargs = dict(\n",
-    "    use_angles=True,\n",
-    "    use_filter_dependent=True,\n",
-    "    use_phase=True,\n",
-    "    use_shape=True,\n",
-    ")\n",
-    "\n",
-    "current_kwargs = base_kwargs.copy()\n",
-    "\n",
-    "SOCCA_params = modelfit.get_fit_params(\n",
-    "    data=pdf_s,\n",
-    "    flavor=\"SOCCA\",\n",
-    "    shg1g2_constrained=True,\n",
-    "    period_blind=True,\n",
-    "    pole_blind=False,\n",
-    "    period_in=None,\n",
-    "    period_quality_flag=True,\n",
-    "    terminator=True,\n",
-    "    time_me=True,\n",
-    "    remap=True,\n",
-    "    remap_kwargs=current_kwargs,\n",
-    ")\n",
-    "\n",
-    "SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fbcc4c56",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "socca",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.19"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/fink_utils/sso/cleaning-example.ipynb b/fink_utils/sso/cleaning-example.ipynb
new file mode 100644
index 0000000..0ab3814
--- /dev/null
+++ b/fink_utils/sso/cleaning-example.ipynb
@@ -0,0 +1,348 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c4cd7a71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pyarrow.dataset as ds\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from fink_utils.sso.spins import estimate_sso_params, func_shg1g2\n",
+    "\n",
+    "from astropy.time import Time\n",
+    "import requests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a3443c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def query(name, epochs):\n",
+    "    \"\"\"Gets asteoid ephemerides from VOSSP Miriade.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    name : str\n",
+    "        Name or designation of asteroid.\n",
+    "    epochs : list\n",
+    "        List of observation epochs in JD format.\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    pd.DataFrame - Input dataframe with ephemerides columns appended\n",
+    "                False - If query failed somehow\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Pass sorted list of epochs to speed up query\n",
+    "    # Have to convert them to JD\n",
+    "    epochs = [Time(str(e), format=\"jd\").jd for e in epochs]\n",
+    "    files = {\"epochs\": (\"epochs\", \"\\n\".join([\"%.6f\" % epoch for epoch in epochs]))}\n",
+    "\n",
+    "    # ------\n",
+    "    # Query Miriade for phase angles\n",
+    "    url = \"https://ssp.imcce.fr/webservices/miriade/api/ephemcc.php?\"\n",
+    "\n",
+    "    params = {\n",
+    "        \"-name\": f\"{name}\",\n",
+    "        \"-mime\": \"json\",\n",
+    "        \"-rplane\": \"1\",\n",
+    "        \"-tcoor\": 5,\n",
+    "        \"-output\": \"--jd\",\n",
+    "        \"-observer\": \"500\",\n",
+    "        \"-tscale\": \"UTC\",\n",
+    "    }\n",
+    "    params['-output'] += f\",--iofile(ephemcc-photom.xml)\"\n",
+    "\n",
+    "    # Execute query\n",
+    "    try:\n",
+    "        r = requests.post(url, params=params, files=files, timeout=50)\n",
+    "    except requests.exceptions.ReadTimeout:\n",
+    "        return False\n",
+    "    j = r.json()\n",
+    "\n",
+    "    # Read JSON response\n",
+    "    try:\n",
+    "        ephem = pd.DataFrame.from_dict(j[\"data\"])\n",
+    "    except KeyError:\n",
+    "        return False\n",
+    "    return ephem\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f7fb7ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "kast = \"00045\"\n",
+    "\n",
+    "dataset = ds.dataset(\"atlas-sscat.v3.0\")\n",
+    "\n",
+    "table = dataset.to_table(filter=ds.field(\"kast\") == kast)\n",
+    "data = table.to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eed89836",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data[\"dxy\"] = np.sqrt(data[\"dx\"]**2 + data[\"dy\"]**2)\n",
+    "data[\"mred\"] = data[\"m\"] - 5 * np.log10(data[\"R\"] * data[\"delta\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9edbfba8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.stats import gaussian_kde\n",
+    "\n",
+    "x = data[\"dxy\"].values\n",
+    "y = data[\"mred\"].values\n",
+    "\n",
+    "xy = np.vstack([x, y])\n",
+    "kde = gaussian_kde(xy)\n",
+    "\n",
+    "xmin, xmax = x.min(), x.max()\n",
+    "ymin, ymax = y.min(), y.max()\n",
+    "\n",
+    "X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]\n",
+    "positions = np.vstack([X.ravel(), Y.ravel()])\n",
+    "\n",
+    "Z = kde(positions).reshape(X.shape)\n",
+    "\n",
+    "Z_flat = Z.ravel()\n",
+    "idx = np.argsort(Z_flat)[::-1]\n",
+    "Z_sorted = Z_flat[idx]\n",
+    "\n",
+    "Z_cumsum = np.cumsum(Z_sorted)\n",
+    "Z_cumsum /= Z_cumsum[-1]\n",
+    "\n",
+    "threshold_index = np.searchsorted(Z_cumsum, 0.95)\n",
+    "level = Z_sorted[threshold_index]\n",
+    "\n",
+    "cond_kde = kde(xy) >= level"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29fdb953",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.scatter(x, y)\n",
+    "ax.contour(X, Y, Z, levels=[level])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "329c38f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_kde = data[cond_kde]\n",
+    "data_inl = data_kde.copy()\n",
+    "\n",
+    "for k in range(11):\n",
+    "    shgg_params = estimate_sso_params(\n",
+    "        data_inl[\"mred\"],\n",
+    "        data_inl[\"dm\"],\n",
+    "        np.radians(data_inl[\"SOE\"]),\n",
+    "        data_inl[\"filt\"],\n",
+    "        np.radians(data_inl[\"ra\"]),\n",
+    "        np.radians(data_inl[\"dec\"]),\n",
+    "        model=\"SHG1G2\",\n",
+    "    )\n",
+    "    fw_model = np.zeros(len(data_inl))\n",
+    "\n",
+    "    for ff in np.unique(data_inl[\"filt\"]):\n",
+    "        mask = data_inl[\"filt\"] == ff\n",
+    "\n",
+    "        pts = func_shg1g2(\n",
+    "            [\n",
+    "                np.radians(data_inl.loc[mask, \"SOE\"]),\n",
+    "                np.radians(data_inl.loc[mask, \"ra\"]),\n",
+    "                np.radians(data_inl.loc[mask, \"dec\"]),\n",
+    "            ],\n",
+    "            shgg_params[f\"H_{ff}\"],\n",
+    "            shgg_params[f\"G1_{ff}\"],\n",
+    "            shgg_params[f\"G2_{ff}\"],\n",
+    "            shgg_params[\"R\"],\n",
+    "            np.radians(shgg_params[\"alpha0\"]),\n",
+    "            np.radians(shgg_params[\"delta0\"]),\n",
+    "        )\n",
+    "        fw_model[mask] = pts\n",
+    "\n",
+    "    residuals = fw_model - data_inl[\"mred\"]\n",
+    "\n",
+    "    threshold = 3 * np.std(residuals)\n",
+    "    cutoff = np.abs(residuals) <= threshold\n",
+    "    \n",
+    "    prev_len = len(data_inl)\n",
+    "    data_inl = data_inl[cutoff]\n",
+    "    new_len = len(data_inl)\n",
+    "\n",
+    "    if prev_len == new_len:\n",
+    "        print(k)\n",
+    "        break\n",
+    "\n",
+    "data_inl = data_inl[cutoff]    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "387106df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.scatter(data[\"SOE\"], data[\"mred\"], label=\"Original set\")\n",
+    "ax.scatter(data_kde[\"SOE\"], data_kde[\"mred\"], label=\"KDE on dxy\", marker=\"P\")\n",
+    "ax.scatter(data_inl[\"SOE\"], data_inl[\"mred\"], label=\"sHG1G2 iterations\", marker=\"*\")\n",
+    "ax.invert_yaxis()\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2346ad21",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import rocks\n",
+    "rockid = str(rocks.Rock(kast).number)\n",
+    "\n",
+    "c_AU_day = 173.14463267424034  # c in AU/day\n",
+    "\n",
+    "data_inl[\"JD_lc\"] = data_inl[\"MJD_lc\"] + 2400000.5\n",
+    "\n",
+    "print(\"Querying ephemerides via IMCCE Miriade..\")\n",
+    "ephem = query(rockid, data_inl[\"JD_lc\"])\n",
+    "\n",
+    "ra_s = ephem[\"RA_h\"].values\n",
+    "dec_s = ephem[\"DEC_h\"].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f3b1e098",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = data_inl.reset_index(drop=True)\n",
+    "\n",
+    "# Rename columns to match Fink format\n",
+    "pdf.rename(\n",
+    "    columns={\n",
+    "        \"SOE\": \"Phase\",\n",
+    "        \"dm\": \"csigmapsf\",\n",
+    "        \"filt\": \"cfid\",\n",
+    "        \"mred\": \"cmred\",\n",
+    "        \"R\":\"Dhelio\"\n",
+    "    },\n",
+    "    inplace=True,\n",
+    ")\n",
+    "\n",
+    "# Add missing columns\n",
+    "\n",
+    "pdf[\"residuals\"] = 0.0\n",
+    "pdf[\"ra_s\"] = ra_s\n",
+    "pdf[\"dec_s\"] = dec_s\n",
+    "\n",
+    "# LT correction\n",
+    "pdf[\"cjd\"] = pdf[\"MJD_lc\"] + 2400000.5  # MJD to JD\n",
+    "\n",
+    "cfid_map = {\"o\": 1, \"c\": 2,}\n",
+    "pdf[\"cfid\"] = pdf[\"cfid\"].map(cfid_map)\n",
+    "\n",
+    "# Make it readable by asteroid_spinprops\n",
+    "pdf_s = pd.DataFrame(\n",
+    "    {col: [np.array(pdf[col])] for col in pdf.columns}\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "344968e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from asteroid_spinprops.ssolib import modelfit\n",
+    "\n",
+    "base_kwargs = dict(\n",
+    "    use_angles=True,\n",
+    "    use_filter_dependent=True,\n",
+    "    use_phase=True,\n",
+    "    use_shape=True,\n",
+    ")\n",
+    "\n",
+    "current_kwargs = base_kwargs.copy()\n",
+    "\n",
+    "SOCCA_params = modelfit.get_fit_params(\n",
+    "    data=pdf_s,\n",
+    "    flavor=\"SOCCA\",\n",
+    "    shg1g2_constrained=True,\n",
+    "    period_blind=True,\n",
+    "    pole_blind=False,\n",
+    "    period_in=None,\n",
+    "    period_quality_flag=True,\n",
+    "    terminator=True,\n",
+    "    time_me=True,\n",
+    "    remap=True,\n",
+    "    remap_kwargs=current_kwargs,\n",
+    ")\n",
+    "\n",
+    "SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbcc4c56",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "socca",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/fink_utils/sso/cleaning.py b/fink_utils/sso/cleaning.py
new file mode 100644
index 0000000..15678d6
--- /dev/null
+++ b/fink_utils/sso/cleaning.py
@@ -0,0 +1,169 @@
+import numpy as np
+from scipy.stats import gaussian_kde
+from fink_utils.sso.spins import estimate_sso_params, func_shg1g2
+
+
+def dxy_cleaning(data, dxy, mag_red):
+    """
+    Filter observations based on their density in (dxy, reduced magnitude) space using a Gaussian KDE.
+
+    A 2D KDE is computed over the (dxy, mag_red) plane.
+    Points are retained if they fall within the 95% highest-density region(s).
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Input dataset containing the observations.
+    dxy : array-like
+        Values of the positional residuals of between the prediction and observed position [pix]
+        computed from sqrt(dx^2 + dy^2)
+    mag_red : array-like
+        Reduced magnitudes corresponding to each observation.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Subset of `data` containing only the retained points.
+
+    Examples
+    --------
+    >>> data_xy = dxy_cleaning(data, data["dxy"], data["mred"])
+    """
+
+    x = dxy
+    y = mag_red
+
+    xy = np.vstack([x, y])
+    kde = gaussian_kde(xy)
+
+    xmin, xmax = x.min(), x.max()
+    ymin, ymax = y.min(), y.max()
+
+    X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
+    positions = np.vstack([X.ravel(), Y.ravel()])
+
+    Z = kde(positions).reshape(X.shape)
+
+    Z_flat = Z.ravel()
+    idx = np.argsort(Z_flat)[::-1]
+    Z_sorted = Z_flat[idx]
+
+    Z_cumsum = np.cumsum(Z_sorted)
+    Z_cumsum /= Z_cumsum[-1]
+
+    threshold_index = np.searchsorted(Z_cumsum, 0.95)
+    level = Z_sorted[threshold_index]
+
+    cond_kde = kde(xy) >= level
+
+    data_kde = data[cond_kde]
+
+    return data_kde
+
+
+def iterative_cleaning(data, mag_red, sigma, phase_angle, filters, ra, dec):
+    """
+    Iteratively filter observations based on residuals from an sHG1G2 photometric model fit.
+
+    An sHG1G2 model is fitted to the data, and residuals between the model and the
+    observed reduced magnitudes are computed. At each iteration, observations with
+    residuals exceeding 3-sigma are removed. The process is repeated until convergence
+    (no further points are rejected) or a maximum of 10 iterations is reached.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Input dataset containing the observations.
+    mag_red : array-like
+        Reduced magnitudes corresponding to each observation.
+    sigma : array-like
+        Uncertainties on the reduced magnitudes.
+    phase_angle : array-like
+        Phase angles of the observations [deg].
+    filters : array-like
+        Photometric filter identifiers for each observation.
+    ra : array-like
+        Right ascension values of the observations [deg].
+    dec : array-like
+        Declination values of the observations [deg].
+
+    Returns
+    -------
+    pandas.DataFrame
+        Subset of `data` containing only the retained points after iterative cleaning.
+
+    Examples
+    --------
+    >>> data_it = iterative_cleaning(
+    ...     data_xy,
+    ...     data_xy["mred"].values,
+    ...     data_xy["dm"].values,
+    ...     data_xy["SOE"].values,
+    ...     data_xy["filt"].values,
+    ...     data_xy["ra"].values,
+    ...     data_xy["dec"].values,
+    ... )
+    """
+
+
+    data_inl, mag_red_inl, sigma_inl, phase_angle_inl, filters_inl, ra_inl, dec_inl = (
+        data.copy(),
+        mag_red.copy(),
+        sigma.copy(),
+        phase_angle.copy(),
+        filters.copy(),
+        ra.copy(),
+        dec.copy(),
+    )
+    for k in range(11):
+        shgg_params = estimate_sso_params(
+            mag_red_inl,
+            sigma_inl,
+            np.radians(phase_angle_inl),
+            filters_inl,
+            np.radians(ra_inl),
+            np.radians(dec_inl),
+            model="SHG1G2",
+        )
+        fw_model = np.zeros(len(data_inl))
+
+        for ff in np.unique(filters_inl):
+            mask = filters_inl == ff
+
+            pts = func_shg1g2(
+                [
+                    np.radians(phase_angle_inl[mask]),
+                    np.radians(ra_inl[mask]),
+                    np.radians(dec_inl[mask]),
+                ],
+                shgg_params[f"H_{ff}"],
+                shgg_params[f"G1_{ff}"],
+                shgg_params[f"G2_{ff}"],
+                shgg_params["R"],
+                np.radians(shgg_params["alpha0"]),
+                np.radians(shgg_params["delta0"]),
+            )
+
+            fw_model[mask] = pts
+
+        residuals = fw_model - mag_red_inl
+
+        threshold = 3 * np.std(residuals)
+        cutoff = np.abs(residuals) <= threshold
+
+        prev_len = len(data_inl)
+
+        data_inl = data_inl[cutoff]
+        mag_red_inl = mag_red_inl[cutoff]
+        sigma_inl = sigma_inl[cutoff]
+        phase_angle_inl = phase_angle_inl[cutoff]
+        filters_inl = filters_inl[cutoff]
+        ra_inl = ra_inl[cutoff]
+        dec_inl = dec_inl[cutoff]
+
+        new_len = len(data_inl)
+        if prev_len == new_len:
+            print("Number of sHG1G2 cleaning iterations:", k)
+            break
+
+    return data_inl

From 8f9b85d94060486b1addd4c5af30e46a69f52a3d Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 15:39:55 +0200
Subject: [PATCH 05/14] linting

---
 fink_utils/sso/cleaning.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/fink_utils/sso/cleaning.py b/fink_utils/sso/cleaning.py
index 15678d6..08b4e92 100644
--- a/fink_utils/sso/cleaning.py
+++ b/fink_utils/sso/cleaning.py
@@ -29,7 +29,6 @@ def dxy_cleaning(data, dxy, mag_red):
     --------
     >>> data_xy = dxy_cleaning(data, data["dxy"], data["mred"])
     """
-
     x = dxy
     y = mag_red
 
@@ -104,8 +103,6 @@ def iterative_cleaning(data, mag_red, sigma, phase_angle, filters, ra, dec):
     ...     data_xy["dec"].values,
     ... )
     """
-
-
     data_inl, mag_red_inl, sigma_inl, phase_angle_inl, filters_inl, ra_inl, dec_inl = (
         data.copy(),
         mag_red.copy(),

From 034d7abb495152808feb3d4a770250fcfb1d52fc Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 15:40:17 +0200
Subject: [PATCH 06/14] linting

---
 fink_utils/sso/cleaning-example.ipynb | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/fink_utils/sso/cleaning-example.ipynb b/fink_utils/sso/cleaning-example.ipynb
index 0ab3814..7cecc95 100644
--- a/fink_utils/sso/cleaning-example.ipynb
+++ b/fink_utils/sso/cleaning-example.ipynb
@@ -58,7 +58,7 @@
     "        \"-observer\": \"500\",\n",
     "        \"-tscale\": \"UTC\",\n",
     "    }\n",
-    "    params['-output'] += f\",--iofile(ephemcc-photom.xml)\"\n",
+    "    params[\"-output\"] += f\",--iofile(ephemcc-photom.xml)\"\n",
     "\n",
     "    # Execute query\n",
     "    try:\n",
@@ -72,7 +72,7 @@
     "        ephem = pd.DataFrame.from_dict(j[\"data\"])\n",
     "    except KeyError:\n",
     "        return False\n",
-    "    return ephem\n"
+    "    return ephem"
    ]
   },
   {
@@ -97,7 +97,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "data[\"dxy\"] = np.sqrt(data[\"dx\"]**2 + data[\"dy\"]**2)\n",
+    "data[\"dxy\"] = np.sqrt(data[\"dx\"] ** 2 + data[\"dy\"] ** 2)\n",
     "data[\"mred\"] = data[\"m\"] - 5 * np.log10(data[\"R\"] * data[\"delta\"])"
    ]
   },
@@ -193,7 +193,7 @@
     "\n",
     "    threshold = 3 * np.std(residuals)\n",
     "    cutoff = np.abs(residuals) <= threshold\n",
-    "    \n",
+    "\n",
     "    prev_len = len(data_inl)\n",
     "    data_inl = data_inl[cutoff]\n",
     "    new_len = len(data_inl)\n",
@@ -202,7 +202,7 @@
     "        print(k)\n",
     "        break\n",
     "\n",
-    "data_inl = data_inl[cutoff]    "
+    "data_inl = data_inl[cutoff]"
    ]
   },
   {
@@ -228,6 +228,7 @@
    "outputs": [],
    "source": [
     "import rocks\n",
+    "\n",
     "rockid = str(rocks.Rock(kast).number)\n",
     "\n",
     "c_AU_day = 173.14463267424034  # c in AU/day\n",
@@ -257,7 +258,7 @@
     "        \"dm\": \"csigmapsf\",\n",
     "        \"filt\": \"cfid\",\n",
     "        \"mred\": \"cmred\",\n",
-    "        \"R\":\"Dhelio\"\n",
+    "        \"R\": \"Dhelio\",\n",
     "    },\n",
     "    inplace=True,\n",
     ")\n",
@@ -271,13 +272,14 @@
     "# LT correction\n",
     "pdf[\"cjd\"] = pdf[\"MJD_lc\"] + 2400000.5  # MJD to JD\n",
     "\n",
-    "cfid_map = {\"o\": 1, \"c\": 2,}\n",
+    "cfid_map = {\n",
+    "    \"o\": 1,\n",
+    "    \"c\": 2,\n",
+    "}\n",
     "pdf[\"cfid\"] = pdf[\"cfid\"].map(cfid_map)\n",
     "\n",
     "# Make it readable by asteroid_spinprops\n",
-    "pdf_s = pd.DataFrame(\n",
-    "    {col: [np.array(pdf[col])] for col in pdf.columns}\n",
-    ")\n"
+    "pdf_s = pd.DataFrame({col: [np.array(pdf[col])] for col in pdf.columns})"
    ]
   },
   {
@@ -312,7 +314,7 @@
     "    remap_kwargs=current_kwargs,\n",
     ")\n",
     "\n",
-    "SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])\n"
+    "SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])"
    ]
   },
   {

From b16e16ff8032c12f7afaad8166a4abff1043de8f Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 15:46:25 +0200
Subject: [PATCH 07/14] linting again

---
 fink_utils/sso/SOCCA-atlas.py         | 14 ++++++--------
 fink_utils/sso/cleaning-example.ipynb | 15 +++++++--------
 fink_utils/sso/spins.py               |  2 +-
 3 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/fink_utils/sso/SOCCA-atlas.py b/fink_utils/sso/SOCCA-atlas.py
index f1923aa..bbd2819 100644
--- a/fink_utils/sso/SOCCA-atlas.py
+++ b/fink_utils/sso/SOCCA-atlas.py
@@ -10,7 +10,6 @@
 import requests
 from asteroid_spinprops.ssolib import modelfit
 import os
-import json
 
 def usage():
     print("""
@@ -56,7 +55,6 @@ def query(name, epochs):
     pd.DataFrame - Input dataframe with ephemerides columns appended
                 False - If query failed somehow
     """
-
     # Pass sorted list of epochs to speed up query
     # Have to convert them to JD
     epochs = [Time(str(e), format="jd").jd for e in epochs]
@@ -75,7 +73,7 @@ def query(name, epochs):
         "-observer": "500",
         "-tscale": "UTC",
     }
-    params["-output"] += f",--iofile(ephemcc-photom.xml)"
+    params["-output"] += ",--iofile(ephemcc-photom.xml)"
 
     # Execute query
     try:
@@ -121,8 +119,8 @@ def main(argv):
     data["dxy"] = np.sqrt(data["dx"] ** 2 + data["dy"] ** 2)
     data["mred"] = data["m"] - 5 * np.log10(data["R"] * data["delta"])
 
-    x = data["dxy"].values
-    y = data["mred"].values
+    x = data["dxy"].to_numpy()
+    y = data["mred"].to_numpy()
 
     xy = np.vstack([x, y])
     kde = gaussian_kde(xy)
@@ -202,8 +200,8 @@ def main(argv):
     print("Querying ephemerides via IMCCE Miriade..")
     ephem = query(rockid, data_inl["JD_lc"])
 
-    ra_s = ephem["RA_h"].values
-    dec_s = ephem["DEC_h"].values
+    ra_s = ephem["RA_h"].to_numpy()
+    dec_s = ephem["DEC_h"].to_numpy()
 
     pdf = data_inl.reset_index(drop=True)
 
@@ -216,7 +214,7 @@ def main(argv):
             "mred": "cmred",
             "R": "Dhelio",
         },
-        inplace=True,
+        # inplace=True,
     )
 
     # Add missing columns
diff --git a/fink_utils/sso/cleaning-example.ipynb b/fink_utils/sso/cleaning-example.ipynb
index 7cecc95..d13f53f 100644
--- a/fink_utils/sso/cleaning-example.ipynb
+++ b/fink_utils/sso/cleaning-example.ipynb
@@ -39,7 +39,6 @@
     "    pd.DataFrame - Input dataframe with ephemerides columns appended\n",
     "                False - If query failed somehow\n",
     "    \"\"\"\n",
-    "\n",
     "    # Pass sorted list of epochs to speed up query\n",
     "    # Have to convert them to JD\n",
     "    epochs = [Time(str(e), format=\"jd\").jd for e in epochs]\n",
@@ -58,7 +57,7 @@
     "        \"-observer\": \"500\",\n",
     "        \"-tscale\": \"UTC\",\n",
     "    }\n",
-    "    params[\"-output\"] += f\",--iofile(ephemcc-photom.xml)\"\n",
+    "    params[\"-output\"] += \",--iofile(ephemcc-photom.xml)\"\n",
     "\n",
     "    # Execute query\n",
     "    try:\n",
@@ -110,8 +109,8 @@
    "source": [
     "from scipy.stats import gaussian_kde\n",
     "\n",
-    "x = data[\"dxy\"].values\n",
-    "y = data[\"mred\"].values\n",
+    "x = data[\"dxy\"].to_numpy()\n",
+    "y = data[\"mred\"].to_numpy()\n",
     "\n",
     "xy = np.vstack([x, y])\n",
     "kde = gaussian_kde(xy)\n",
@@ -231,15 +230,15 @@
     "\n",
     "rockid = str(rocks.Rock(kast).number)\n",
     "\n",
-    "c_AU_day = 173.14463267424034  # c in AU/day\n",
+    "c_au_day = 173.14463267424034  # c in AU/day\n",
     "\n",
     "data_inl[\"JD_lc\"] = data_inl[\"MJD_lc\"] + 2400000.5\n",
     "\n",
     "print(\"Querying ephemerides via IMCCE Miriade..\")\n",
     "ephem = query(rockid, data_inl[\"JD_lc\"])\n",
     "\n",
-    "ra_s = ephem[\"RA_h\"].values\n",
-    "dec_s = ephem[\"DEC_h\"].values"
+    "ra_s = ephem[\"RA_h\"].to_numpy()\n",
+    "dec_s = ephem[\"DEC_h\"].to_numpy()"
    ]
   },
   {
@@ -260,7 +259,7 @@
     "        \"mred\": \"cmred\",\n",
     "        \"R\": \"Dhelio\",\n",
     "    },\n",
-    "    inplace=True,\n",
+    "    # inplace=True,\n",
     ")\n",
     "\n",
     "# Add missing columns\n",
diff --git a/fink_utils/sso/spins.py b/fink_utils/sso/spins.py
index fd98f34..50abde1 100644
--- a/fink_utils/sso/spins.py
+++ b/fink_utils/sso/spins.py
@@ -2185,7 +2185,7 @@ def fit_spin(
             loss="soft_l1",
             args=args,
         )
-    except (RuntimeError, ValueError) as e:
+    except (RuntimeError, ValueError):
         outdic = {"fit": 3, "status": -2}
         return outdic
 

From 09055f2d35933d58d2490645d2344cb2d9b552b5 Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 15:52:13 +0200
Subject: [PATCH 08/14] linting again

---
 fink_utils/sso/SOCCA-atlas.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fink_utils/sso/SOCCA-atlas.py b/fink_utils/sso/SOCCA-atlas.py
index bbd2819..20e2629 100644
--- a/fink_utils/sso/SOCCA-atlas.py
+++ b/fink_utils/sso/SOCCA-atlas.py
@@ -11,6 +11,7 @@
 from asteroid_spinprops.ssolib import modelfit
 import os
 
+
 def usage():
     print("""
 SOCCA - ATLAS

From a9c3c8c8236154e4e758e242a18d65a833a69ca3 Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Wed, 8 Apr 2026 15:54:31 +0200
Subject: [PATCH 09/14] is ruff happy?

---
 fink_utils/sso/spins.py | 48 ++++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 27 deletions(-)

diff --git a/fink_utils/sso/spins.py b/fink_utils/sso/spins.py
index 50abde1..aa6075e 100644
--- a/fink_utils/sso/spins.py
+++ b/fink_utils/sso/spins.py
@@ -1406,14 +1406,12 @@ def build_eqs_for_spin_shape(
 
             myfunc = (
                 func_socca(
-                    np.vstack(
-                        [
-                            ph[mask].tolist(),
-                            ra[mask].tolist(),
-                            dec[mask].tolist(),
-                            jd[mask].tolist(),
-                        ]
-                    ),
+                    np.vstack([
+                        ph[mask].tolist(),
+                        ra[mask].tolist(),
+                        dec[mask].tolist(),
+                        jd[mask].tolist(),
+                    ]),
                     params_per_band[index][0],
                     params_per_band[index][1],
                     params_per_band[index][2],
@@ -1434,16 +1432,14 @@ def build_eqs_for_spin_shape(
 
             myfunc = (
                 func_socca_terminator(
-                    np.vstack(
-                        [
-                            ph[mask].tolist(),
-                            ra[mask].tolist(),
-                            dec[mask].tolist(),
-                            jd[mask].tolist(),
-                            ra_s[mask].tolist(),
-                            dec_s[mask].tolist(),
-                        ]
-                    ),
+                    np.vstack([
+                        ph[mask].tolist(),
+                        ra[mask].tolist(),
+                        dec[mask].tolist(),
+                        jd[mask].tolist(),
+                        ra_s[mask].tolist(),
+                        dec_s[mask].tolist(),
+                    ]),
                     params_per_band[index][0],
                     params_per_band[index][1],
                     params_per_band[index][2],
@@ -1921,15 +1917,13 @@ def fit_sfhg1g2(
         outdic = {"fit": 1, "status": -2}
         return outdic
 
-    pdf = pd.DataFrame(
-        {
-            "i:magpsf_red": magpsf_red,
-            "i:sigmapsf": sigmapsf,
-            "Phase": phase,
-            "i:jd": jds,
-            "i:fid": filters,
-        }
-    )
+    pdf = pd.DataFrame({
+        "i:magpsf_red": magpsf_red,
+        "i:sigmapsf": sigmapsf,
+        "Phase": phase,
+        "i:jd": jds,
+        "i:fid": filters,
+    })
     pdf = pdf.sort_values("i:jd")
 
     # Get oppositions

From bf727f5e8d28066d43c4b1cef9f0aea0f102ed50 Mon Sep 17 00:00:00 2001
From: JulienPeloton <peloton@lal.in2p3.fr>
Date: Mon, 27 Apr 2026 13:59:20 +0200
Subject: [PATCH 10/14] isolate files unrelated to the package files

---
 fink_utils/sso/{ => misc}/SOCCA-atlas.py         | 0
 fink_utils/sso/{ => misc}/cleaning-example.ipynb | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename fink_utils/sso/{ => misc}/SOCCA-atlas.py (100%)
 rename fink_utils/sso/{ => misc}/cleaning-example.ipynb (100%)

diff --git a/fink_utils/sso/SOCCA-atlas.py b/fink_utils/sso/misc/SOCCA-atlas.py
similarity index 100%
rename from fink_utils/sso/SOCCA-atlas.py
rename to fink_utils/sso/misc/SOCCA-atlas.py
diff --git a/fink_utils/sso/cleaning-example.ipynb b/fink_utils/sso/misc/cleaning-example.ipynb
similarity index 100%
rename from fink_utils/sso/cleaning-example.ipynb
rename to fink_utils/sso/misc/cleaning-example.ipynb

From 3be8db885f70b8372ef2ea240cdc373660cf3a8f Mon Sep 17 00:00:00 2001
From: JulienPeloton <peloton@lal.in2p3.fr>
Date: Mon, 27 Apr 2026 14:53:21 +0200
Subject: [PATCH 11/14] WP: add test suite

---
 fink_utils/sso/cleaning.py | 45 +++++++++++++++++++++++++++++++++++---
 1 file changed, 42 insertions(+), 3 deletions(-)

diff --git a/fink_utils/sso/cleaning.py b/fink_utils/sso/cleaning.py
index 08b4e92..7329044 100644
--- a/fink_utils/sso/cleaning.py
+++ b/fink_utils/sso/cleaning.py
@@ -1,14 +1,35 @@
+# Copyright 2026 AstroLab Software
+# Author: Odysseas Xenos
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Utilities for cleaning data before calling SOCCA"""
+
 import numpy as np
 from scipy.stats import gaussian_kde
+
 from fink_utils.sso.spins import estimate_sso_params, func_shg1g2
 
+from fink_utils.tester import regular_unit_tests
 
-def dxy_cleaning(data, dxy, mag_red):
+
+def dxy_cleaning(data, dxy, mag_red, threshold=0.95):
     """
     Filter observations based on their density in (dxy, reduced magnitude) space using a Gaussian KDE.
 
+    Notes
+    -----
     A 2D KDE is computed over the (dxy, mag_red) plane.
-    Points are retained if they fall within the 95% highest-density region(s).
+    Points are retained if they fall within the 95% (default) highest-density region(s).
 
     Parameters
     ----------
@@ -27,6 +48,17 @@ def dxy_cleaning(data, dxy, mag_red):
 
     Examples
     --------
+    >>> import pandas as pd
+    >>> pdf = pd.read_parquet('fink_utils/test_data/agg_benoit_julien_2024/')
+    >>> data = pd.DataFrame.from_dict(pdf.head(1).to_dict(orient='records')[0])
+
+    # Dummy values
+    >>> data["dx"] = np.random.normal(0, 1, size=len(data))
+    >>> data["dy"] = np.random.normal(0, 1, size=len(data))
+    >>> data["dxy"] = np.sqrt(data["dx"] ** 2 + data["dy"] ** 2)
+
+    # Dummy values
+    >>> data["mred"] = data["cmagpsf"]
     >>> data_xy = dxy_cleaning(data, data["dxy"], data["mred"])
     """
     x = dxy
@@ -50,7 +82,7 @@ def dxy_cleaning(data, dxy, mag_red):
     Z_cumsum = np.cumsum(Z_sorted)
     Z_cumsum /= Z_cumsum[-1]
 
-    threshold_index = np.searchsorted(Z_cumsum, 0.95)
+    threshold_index = np.searchsorted(Z_cumsum, threshold)
     level = Z_sorted[threshold_index]
 
     cond_kde = kde(xy) >= level
@@ -164,3 +196,10 @@ def iterative_cleaning(data, mag_red, sigma, phase_angle, filters, ra, dec):
             break
 
     return data_inl
+
+
+if __name__ == "__main__":
+    """Execute the unit test suite"""
+
+    # Run the test suite
+    regular_unit_tests(globals())

From b85918def2934d49c6c69ad47519bc07b2207ab1 Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Fri, 29 May 2026 11:16:03 +0200
Subject: [PATCH 12/14] Add a function to perform an F-test between phase curve
 models

---
 fink_utils/sso/utils.py | 109 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/fink_utils/sso/utils.py b/fink_utils/sso/utils.py
index 7f73f98..a2f7aff 100644
--- a/fink_utils/sso/utils.py
+++ b/fink_utils/sso/utils.py
@@ -534,6 +534,115 @@ def get_opposition(jds, ssnamenr, location="I41"):
 
     return pdf[["elong", "elongFlag"]].to_numpy()
 
+def f_test_models(nfilt, nobs, models, rms_per_model):
+    """
+    Perform pairwise F-tests between phase curve models.
+
+    This function compares model fits using an F-test based on RMS values
+    and degrees of freedom, evaluating whether the addition of parameters
+    in a more complex model significantly improves the fit relative to a
+    simpler model.
+
+    The test is only applied in the valid direction:
+    from simpler models (fewer parameters) to more complex models.
+
+    Parameters
+    ----------
+    nfilt : int or array-like
+        Number of filters used in the fit. Can be a scalar (object-by-object mode)
+        or an array (vectorized mode over multiple objects).
+
+    nobs : int or array-like
+        Number of observations. Can be scalar or array-like.
+
+    models : list of str
+        List of model names to compare. Supported keys must exist in `dof_dict`.
+        Currently supported:
+            - HG
+            - HG12
+            - HG1G2
+            - SHG1G2
+            - SOCCA
+
+    rms_per_model : list of array-like
+        RMS values for each model, ordered consistently with `models`.
+        Each entry can be:
+            - scalar (single-object), or
+            - array-like (vectorized mode over many objects)
+
+    Returns
+    -------
+    dict
+        Dictionary where keys are `"model1_model2"` and values are:
+            - int (0 or 1) in scalar mode
+            - np.ndarray in vectorized mode
+
+        A value of 1 indicates that model2 significantly improves over model1
+        at the 99% confidence level.
+
+    Examples
+    --------
+
+    Scalar (single object)
+    -----------------------
+    >>> nfilt = 2
+    >>> nobs = 120
+    >>> models = ["HG", "HG1G2"]
+    >>> rms = [0.12, 0.08]
+    >>> out = f_test_models(nfilt, nobs, models, rms)
+    >>> out
+    {'HG_HG1G2': 1}
+
+    Vectorized (multiple objects)
+    -----------------------------
+    >>> import numpy as np
+    >>> nfilt = np.full(1000, 2)
+    >>> nobs = np.full(1000, 120)
+    >>> models = ["HG", "HG1G2"]
+    >>> rms = [
+            np.random.normal(0.1, 0.02, 1000),
+            np.random.normal(0.08, 0.02, 1000),
+        ]
+    >>> out = f_test_models(nfilt, nobs, models, rms)
+    >>> out["HG_HG1G2"].shape
+    (1000,)
+
+    """
+    import scipy.stats
+
+    dof_dict = {
+        "HG": 2 * nfilt,
+        "HG12": 2 * nfilt,
+        "HG1G2": 3 * nfilt,
+        "SHG1G2": 3 * nfilt + 3,
+        "SOCCA": 3 * nfilt + 7,
+    }
+
+    store_comparisons = {}
+
+    for i, m1 in enumerate(models):
+        for j, m2 in enumerate(models):
+            if m1 == m2:
+                continue
+
+            # test simpler -> more complex
+            if np.all(dof_dict[m2] <= dof_dict[m1]):
+                continue
+            dfn = dof_dict[m2] - dof_dict[m1]
+            dfd = nobs - dof_dict[m2]
+
+            F = (((rms_per_model[i] ** 2) / (rms_per_model[j] ** 2)) - 1) * (dfd / dfn)
+
+            alpha = scipy.stats.f.ppf(
+                q=0.99,
+                dfn=dfn,
+                dfd=dfd,
+            )
+
+            passed = (F > alpha).astype(int)
+            store_comparisons[f"{m1}_{m2}"] = passed
+
+    return store_comparisons
 
 if __name__ == "__main__":
     """Execute the unit test suite"""

From 988db025ed41ab4519df232b1c8f285ab163e6f6 Mon Sep 17 00:00:00 2001
From: Odysseas XENOS <odysseas.xenos@proton.me>
Date: Tue, 2 Jun 2026 09:22:15 +0200
Subject: [PATCH 13/14] remove obsolete scripts

---
 fink_utils/sso/misc/SOCCA-atlas.py         | 268 ----------------
 fink_utils/sso/misc/cleaning-example.ipynb | 349 ---------------------
 2 files changed, 617 deletions(-)
 delete mode 100644 fink_utils/sso/misc/SOCCA-atlas.py
 delete mode 100644 fink_utils/sso/misc/cleaning-example.ipynb

diff --git a/fink_utils/sso/misc/SOCCA-atlas.py b/fink_utils/sso/misc/SOCCA-atlas.py
deleted file mode 100644
index 20e2629..0000000
--- a/fink_utils/sso/misc/SOCCA-atlas.py
+++ /dev/null
@@ -1,268 +0,0 @@
-import pandas as pd
-import numpy as np
-from fink_utils.sso.spins import estimate_sso_params, func_shg1g2
-import getopt
-import sys
-import pyarrow.dataset as ds
-from scipy.stats import gaussian_kde
-import rocks
-from astropy.time import Time
-import requests
-from asteroid_spinprops.ssolib import modelfit
-import os
-
-
-def usage():
-    print("""
-SOCCA - ATLAS
---------------------------------------------------------------------------
-Description:
-    This script reads and cleans ATLAS v3 SSO photometric data and fits SOCCA to them.
-
-Usage:
-    python SOCCA-atlas.py -d <path_data> -t <output_dir> -n <sso_name>
-
-Required arguments:
-    -d, --path_data     Path to the input parquet dataset directory
-    -t, --target        Output directory for the resulting SOCCA parameters (CSV file)
-    -n, --target        Asteroid packed designation (SSO identifier)
-
-Optional:
-    -h, --help          Show this help message and exit
-
-Example for (45) Eugenia:
-    python SOCCA-atlas.py -d ./dataset -t ./results/ -n 00045
-
-Notes:
-    - The dataset must contain fields:
-        kast, dx, dy, m, R, delta, dm, SOE, filt, ra, dec, MJD_lc
-    - Output will be written as:
-        <output_dir>/<sso_name>.csv
-""")
-
-
-def query(name, epochs):
-    """Gets asteoid ephemerides from VOSSP Miriade.
-
-    Parameters
-    ----------
-    name : str
-        Name or designation of asteroid.
-    epochs : list
-        List of observation epochs in JD format.
-
-    Returns
-    -------
-    pd.DataFrame - Input dataframe with ephemerides columns appended
-                False - If query failed somehow
-    """
-    # Pass sorted list of epochs to speed up query
-    # Have to convert them to JD
-    epochs = [Time(str(e), format="jd").jd for e in epochs]
-    files = {"epochs": ("epochs", "\n".join(["%.6f" % epoch for epoch in epochs]))}
-
-    # ------
-    # Query Miriade for phase angles
-    url = "https://ssp.imcce.fr/webservices/miriade/api/ephemcc.php?"
-
-    params = {
-        "-name": f"{name}",
-        "-mime": "json",
-        "-rplane": "1",
-        "-tcoor": 5,
-        "-output": "--jd",
-        "-observer": "500",
-        "-tscale": "UTC",
-    }
-    params["-output"] += ",--iofile(ephemcc-photom.xml)"
-
-    # Execute query
-    try:
-        r = requests.post(url, params=params, files=files, timeout=50)
-    except requests.exceptions.ReadTimeout:
-        return False
-    j = r.json()
-
-    # Read JSON response
-    try:
-        ephem = pd.DataFrame.from_dict(j["data"])
-    except KeyError:
-        return False
-    return ephem
-
-
-def main(argv):
-    opts, _ = getopt.getopt(
-        argv,
-        "d:t:n:h",
-        [
-            "path_data=",
-            "target=",
-            "sso_name=",
-            "help",
-        ],
-    )
-    args = dict(opts)
-
-    if "--help" in args or "-h" in args:
-        usage()
-        sys.exit()
-
-    output_dir = args.get("-t") or args.get("--target")
-    path_data = args.get("-d") or args.get("--path_data")
-    ssnamenr = args.get("-n") or args.get("--sso_name")
-
-    dataset = ds.dataset(path_data)
-
-    table = dataset.to_table(filter=ds.field("kast") == ssnamenr)
-    data = table.to_pandas()
-
-    data["dxy"] = np.sqrt(data["dx"] ** 2 + data["dy"] ** 2)
-    data["mred"] = data["m"] - 5 * np.log10(data["R"] * data["delta"])
-
-    x = data["dxy"].to_numpy()
-    y = data["mred"].to_numpy()
-
-    xy = np.vstack([x, y])
-    kde = gaussian_kde(xy)
-
-    xmin, xmax = x.min(), x.max()
-    ymin, ymax = y.min(), y.max()
-
-    X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
-    positions = np.vstack([X.ravel(), Y.ravel()])
-
-    Z = kde(positions).reshape(X.shape)
-
-    Z_flat = Z.ravel()
-    idx = np.argsort(Z_flat)[::-1]
-    Z_sorted = Z_flat[idx]
-
-    Z_cumsum = np.cumsum(Z_sorted)
-    Z_cumsum /= Z_cumsum[-1]
-
-    threshold_index = np.searchsorted(Z_cumsum, 0.95)
-    level = Z_sorted[threshold_index]
-
-    cond_kde = kde(xy) >= level
-
-    data_kde = data[cond_kde]
-    data_inl = data_kde.copy()
-
-    for k in range(11):
-        shgg_params = estimate_sso_params(
-            data_inl["mred"],
-            data_inl["dm"],
-            np.radians(data_inl["SOE"]),
-            data_inl["filt"],
-            np.radians(data_inl["ra"]),
-            np.radians(data_inl["dec"]),
-            model="SHG1G2",
-        )
-        fw_model = np.zeros(len(data_inl))
-
-        for ff in np.unique(data_inl["filt"]):
-            mask = data_inl["filt"] == ff
-
-            pts = func_shg1g2(
-                [
-                    np.radians(data_inl.loc[mask, "SOE"]),
-                    np.radians(data_inl.loc[mask, "ra"]),
-                    np.radians(data_inl.loc[mask, "dec"]),
-                ],
-                shgg_params[f"H_{ff}"],
-                shgg_params[f"G1_{ff}"],
-                shgg_params[f"G2_{ff}"],
-                shgg_params["R"],
-                np.radians(shgg_params["alpha0"]),
-                np.radians(shgg_params["delta0"]),
-            )
-            fw_model[mask] = pts
-
-        residuals = fw_model - data_inl["mred"]
-
-        threshold = 3 * np.std(residuals)
-        cutoff = np.abs(residuals) <= threshold
-
-        prev_len = len(data_inl)
-        data_inl = data_inl[cutoff]
-        new_len = len(data_inl)
-
-        if prev_len == new_len:
-            print("Number of sHG1G2 cleaning iterations:", k)
-            break
-
-    data_inl = data_inl[cutoff]
-
-    rockid = str(rocks.Rock(ssnamenr).number)
-
-    data_inl["JD_lc"] = data_inl["MJD_lc"] + 2400000.5
-
-    print("Querying ephemerides via IMCCE Miriade..")
-    ephem = query(rockid, data_inl["JD_lc"])
-
-    ra_s = ephem["RA_h"].to_numpy()
-    dec_s = ephem["DEC_h"].to_numpy()
-
-    pdf = data_inl.reset_index(drop=True)
-
-    # Rename columns to match Fink format
-    pdf.rename(
-        columns={
-            "SOE": "Phase",
-            "dm": "csigmapsf",
-            "filt": "cfid",
-            "mred": "cmred",
-            "R": "Dhelio",
-        },
-        # inplace=True,
-    )
-
-    # Add missing columns
-
-    pdf["residuals"] = 0.0
-    pdf["ra_s"] = ra_s
-    pdf["dec_s"] = dec_s
-
-    # LT correction
-    pdf["cjd"] = pdf["MJD_lc"] + 2400000.5  # MJD to JD
-
-    cfid_map = {
-        "o": 1,
-        "c": 2,
-    }
-    pdf["cfid"] = pdf["cfid"].map(cfid_map)
-
-    # Make it readable by asteroid_spinprops
-    pdf_s = pd.DataFrame({col: [np.array(pdf[col])] for col in pdf.columns})
-
-    base_kwargs = dict(
-        use_angles=True,
-        use_filter_dependent=True,
-        use_phase=True,
-        use_shape=True,
-    )
-
-    current_kwargs = base_kwargs.copy()
-
-    SOCCA_params = modelfit.get_fit_params(
-        data=pdf_s,
-        flavor="SOCCA",
-        shg1g2_constrained=True,
-        period_blind=True,
-        pole_blind=False,
-        period_in=None,
-        period_quality_flag=True,
-        terminator=True,
-        time_me=True,
-        remap=True,
-        remap_kwargs=current_kwargs,
-    )
-
-    SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])
-
-    SOCCA_out.to_csv(os.path.join(output_dir, ssnamenr + ".csv"), index=None)
-
-
-if __name__ == "__main__":
-    main(sys.argv[1:])
diff --git a/fink_utils/sso/misc/cleaning-example.ipynb b/fink_utils/sso/misc/cleaning-example.ipynb
deleted file mode 100644
index d13f53f..0000000
--- a/fink_utils/sso/misc/cleaning-example.ipynb
+++ /dev/null
@@ -1,349 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c4cd7a71",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pyarrow.dataset as ds\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "from fink_utils.sso.spins import estimate_sso_params, func_shg1g2\n",
-    "\n",
-    "from astropy.time import Time\n",
-    "import requests"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5a3443c9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def query(name, epochs):\n",
-    "    \"\"\"Gets asteoid ephemerides from VOSSP Miriade.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    name : str\n",
-    "        Name or designation of asteroid.\n",
-    "    epochs : list\n",
-    "        List of observation epochs in JD format.\n",
-    "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    pd.DataFrame - Input dataframe with ephemerides columns appended\n",
-    "                False - If query failed somehow\n",
-    "    \"\"\"\n",
-    "    # Pass sorted list of epochs to speed up query\n",
-    "    # Have to convert them to JD\n",
-    "    epochs = [Time(str(e), format=\"jd\").jd for e in epochs]\n",
-    "    files = {\"epochs\": (\"epochs\", \"\\n\".join([\"%.6f\" % epoch for epoch in epochs]))}\n",
-    "\n",
-    "    # ------\n",
-    "    # Query Miriade for phase angles\n",
-    "    url = \"https://ssp.imcce.fr/webservices/miriade/api/ephemcc.php?\"\n",
-    "\n",
-    "    params = {\n",
-    "        \"-name\": f\"{name}\",\n",
-    "        \"-mime\": \"json\",\n",
-    "        \"-rplane\": \"1\",\n",
-    "        \"-tcoor\": 5,\n",
-    "        \"-output\": \"--jd\",\n",
-    "        \"-observer\": \"500\",\n",
-    "        \"-tscale\": \"UTC\",\n",
-    "    }\n",
-    "    params[\"-output\"] += \",--iofile(ephemcc-photom.xml)\"\n",
-    "\n",
-    "    # Execute query\n",
-    "    try:\n",
-    "        r = requests.post(url, params=params, files=files, timeout=50)\n",
-    "    except requests.exceptions.ReadTimeout:\n",
-    "        return False\n",
-    "    j = r.json()\n",
-    "\n",
-    "    # Read JSON response\n",
-    "    try:\n",
-    "        ephem = pd.DataFrame.from_dict(j[\"data\"])\n",
-    "    except KeyError:\n",
-    "        return False\n",
-    "    return ephem"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8f7fb7ec",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "kast = \"00045\"\n",
-    "\n",
-    "dataset = ds.dataset(\"atlas-sscat.v3.0\")\n",
-    "\n",
-    "table = dataset.to_table(filter=ds.field(\"kast\") == kast)\n",
-    "data = table.to_pandas()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "eed89836",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data[\"dxy\"] = np.sqrt(data[\"dx\"] ** 2 + data[\"dy\"] ** 2)\n",
-    "data[\"mred\"] = data[\"m\"] - 5 * np.log10(data[\"R\"] * data[\"delta\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9edbfba8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from scipy.stats import gaussian_kde\n",
-    "\n",
-    "x = data[\"dxy\"].to_numpy()\n",
-    "y = data[\"mred\"].to_numpy()\n",
-    "\n",
-    "xy = np.vstack([x, y])\n",
-    "kde = gaussian_kde(xy)\n",
-    "\n",
-    "xmin, xmax = x.min(), x.max()\n",
-    "ymin, ymax = y.min(), y.max()\n",
-    "\n",
-    "X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]\n",
-    "positions = np.vstack([X.ravel(), Y.ravel()])\n",
-    "\n",
-    "Z = kde(positions).reshape(X.shape)\n",
-    "\n",
-    "Z_flat = Z.ravel()\n",
-    "idx = np.argsort(Z_flat)[::-1]\n",
-    "Z_sorted = Z_flat[idx]\n",
-    "\n",
-    "Z_cumsum = np.cumsum(Z_sorted)\n",
-    "Z_cumsum /= Z_cumsum[-1]\n",
-    "\n",
-    "threshold_index = np.searchsorted(Z_cumsum, 0.95)\n",
-    "level = Z_sorted[threshold_index]\n",
-    "\n",
-    "cond_kde = kde(xy) >= level"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "29fdb953",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fig, ax = plt.subplots()\n",
-    "ax.scatter(x, y)\n",
-    "ax.contour(X, Y, Z, levels=[level])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "329c38f7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_kde = data[cond_kde]\n",
-    "data_inl = data_kde.copy()\n",
-    "\n",
-    "for k in range(11):\n",
-    "    shgg_params = estimate_sso_params(\n",
-    "        data_inl[\"mred\"],\n",
-    "        data_inl[\"dm\"],\n",
-    "        np.radians(data_inl[\"SOE\"]),\n",
-    "        data_inl[\"filt\"],\n",
-    "        np.radians(data_inl[\"ra\"]),\n",
-    "        np.radians(data_inl[\"dec\"]),\n",
-    "        model=\"SHG1G2\",\n",
-    "    )\n",
-    "    fw_model = np.zeros(len(data_inl))\n",
-    "\n",
-    "    for ff in np.unique(data_inl[\"filt\"]):\n",
-    "        mask = data_inl[\"filt\"] == ff\n",
-    "\n",
-    "        pts = func_shg1g2(\n",
-    "            [\n",
-    "                np.radians(data_inl.loc[mask, \"SOE\"]),\n",
-    "                np.radians(data_inl.loc[mask, \"ra\"]),\n",
-    "                np.radians(data_inl.loc[mask, \"dec\"]),\n",
-    "            ],\n",
-    "            shgg_params[f\"H_{ff}\"],\n",
-    "            shgg_params[f\"G1_{ff}\"],\n",
-    "            shgg_params[f\"G2_{ff}\"],\n",
-    "            shgg_params[\"R\"],\n",
-    "            np.radians(shgg_params[\"alpha0\"]),\n",
-    "            np.radians(shgg_params[\"delta0\"]),\n",
-    "        )\n",
-    "        fw_model[mask] = pts\n",
-    "\n",
-    "    residuals = fw_model - data_inl[\"mred\"]\n",
-    "\n",
-    "    threshold = 3 * np.std(residuals)\n",
-    "    cutoff = np.abs(residuals) <= threshold\n",
-    "\n",
-    "    prev_len = len(data_inl)\n",
-    "    data_inl = data_inl[cutoff]\n",
-    "    new_len = len(data_inl)\n",
-    "\n",
-    "    if prev_len == new_len:\n",
-    "        print(k)\n",
-    "        break\n",
-    "\n",
-    "data_inl = data_inl[cutoff]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "387106df",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fig, ax = plt.subplots()\n",
-    "ax.scatter(data[\"SOE\"], data[\"mred\"], label=\"Original set\")\n",
-    "ax.scatter(data_kde[\"SOE\"], data_kde[\"mred\"], label=\"KDE on dxy\", marker=\"P\")\n",
-    "ax.scatter(data_inl[\"SOE\"], data_inl[\"mred\"], label=\"sHG1G2 iterations\", marker=\"*\")\n",
-    "ax.invert_yaxis()\n",
-    "ax.legend()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2346ad21",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import rocks\n",
-    "\n",
-    "rockid = str(rocks.Rock(kast).number)\n",
-    "\n",
-    "c_au_day = 173.14463267424034  # c in AU/day\n",
-    "\n",
-    "data_inl[\"JD_lc\"] = data_inl[\"MJD_lc\"] + 2400000.5\n",
-    "\n",
-    "print(\"Querying ephemerides via IMCCE Miriade..\")\n",
-    "ephem = query(rockid, data_inl[\"JD_lc\"])\n",
-    "\n",
-    "ra_s = ephem[\"RA_h\"].to_numpy()\n",
-    "dec_s = ephem[\"DEC_h\"].to_numpy()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f3b1e098",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pdf = data_inl.reset_index(drop=True)\n",
-    "\n",
-    "# Rename columns to match Fink format\n",
-    "pdf.rename(\n",
-    "    columns={\n",
-    "        \"SOE\": \"Phase\",\n",
-    "        \"dm\": \"csigmapsf\",\n",
-    "        \"filt\": \"cfid\",\n",
-    "        \"mred\": \"cmred\",\n",
-    "        \"R\": \"Dhelio\",\n",
-    "    },\n",
-    "    # inplace=True,\n",
-    ")\n",
-    "\n",
-    "# Add missing columns\n",
-    "\n",
-    "pdf[\"residuals\"] = 0.0\n",
-    "pdf[\"ra_s\"] = ra_s\n",
-    "pdf[\"dec_s\"] = dec_s\n",
-    "\n",
-    "# LT correction\n",
-    "pdf[\"cjd\"] = pdf[\"MJD_lc\"] + 2400000.5  # MJD to JD\n",
-    "\n",
-    "cfid_map = {\n",
-    "    \"o\": 1,\n",
-    "    \"c\": 2,\n",
-    "}\n",
-    "pdf[\"cfid\"] = pdf[\"cfid\"].map(cfid_map)\n",
-    "\n",
-    "# Make it readable by asteroid_spinprops\n",
-    "pdf_s = pd.DataFrame({col: [np.array(pdf[col])] for col in pdf.columns})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "344968e0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from asteroid_spinprops.ssolib import modelfit\n",
-    "\n",
-    "base_kwargs = dict(\n",
-    "    use_angles=True,\n",
-    "    use_filter_dependent=True,\n",
-    "    use_phase=True,\n",
-    "    use_shape=True,\n",
-    ")\n",
-    "\n",
-    "current_kwargs = base_kwargs.copy()\n",
-    "\n",
-    "SOCCA_params = modelfit.get_fit_params(\n",
-    "    data=pdf_s,\n",
-    "    flavor=\"SOCCA\",\n",
-    "    shg1g2_constrained=True,\n",
-    "    period_blind=True,\n",
-    "    pole_blind=False,\n",
-    "    period_in=None,\n",
-    "    period_quality_flag=True,\n",
-    "    terminator=True,\n",
-    "    time_me=True,\n",
-    "    remap=True,\n",
-    "    remap_kwargs=current_kwargs,\n",
-    ")\n",
-    "\n",
-    "SOCCA_out = pd.DataFrame.from_dict([SOCCA_params])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fbcc4c56",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "socca",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.19"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

From 0edf3ce87a249557f5842ad93795d7ba9c575387 Mon Sep 17 00:00:00 2001
From: JulienPeloton <peloton@lal.in2p3.fr>
Date: Tue, 2 Jun 2026 15:41:04 +0200
Subject: [PATCH 14/14] PEP8

---
 fink_utils/sso/utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fink_utils/sso/utils.py b/fink_utils/sso/utils.py
index 8f1a489..7e5df0d 100644
--- a/fink_utils/sso/utils.py
+++ b/fink_utils/sso/utils.py
@@ -534,6 +534,7 @@ def get_opposition(jds, ssnamenr, location="I41"):
 
     return pdf[["elong", "elongFlag"]].to_numpy()
 
+
 def f_test_models(nfilt, nobs, models, rms_per_model):
     """
     Perform pairwise F-tests between phase curve models.
@@ -582,7 +583,6 @@ def f_test_models(nfilt, nobs, models, rms_per_model):
 
     Examples
     --------
-
     Scalar (single object)
     -----------------------
     >>> nfilt = 2
@@ -644,6 +644,7 @@ def f_test_models(nfilt, nobs, models, rms_per_model):
 
     return store_comparisons
 
+
 if __name__ == "__main__":
     """Execute the unit test suite"""