timewise 1.0.0a1__tar.gz → 1.0.0a2__tar.gz

{timewise-1.0.0a1 → timewise-1.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: timewise
-Version: 1.0.0a1
+Version: 1.0.0a2
 Summary: Download WISE infrared data for many objects and process them with AMPEL
 License: MIT
 License-File: LICENSE

{timewise-1.0.0a1 → timewise-1.0.0a2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "timewise"
-version = "1.0.0a1"
+version = "1.0.0a2"
 description = "Download WISE infrared data for many objects and process them with AMPEL"
 authors = [
     { name = "Jannis Necker", email = "jannis.necker@gmail.com" },

timewise-1.0.0a2/timewise/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0a2"

{timewise-1.0.0a1 → timewise-1.0.0a2}/timewise/plot/diagnostic.py

@@ -106,7 +106,7 @@ class DiagnosticPlotter(BaseModel):
         dec = (raw_lightcurve.dec - source_dec) * 3600
 
         # get visit map
-        visit_map = get_visit_map(raw_lightcurve)
+        visit_map = get_visit_map(raw_lightcurve.mjd)
 
         # for each visit plot the datapoints on the cutout
         # for each visit plot the datapoints on the cutout

{timewise-1.0.0a1 → timewise-1.0.0a2}/timewise/process/config.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 import logging
 
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
 
 from .interface import AmpelInterface
 
@@ -14,10 +14,14 @@ class AmpelConfig(BaseModel):
     mongo_db_name: str
     template_path: Path = DEFAULT_TEMPLATE_PATH
     uri: str = "localhost:27017"
-
-    @property
-    def input_mongo_db_name(self) -> str:
-        return self.mongo_db_name + "_input"
+    # will default to <mongo_db_name>_input
+    input_mongo_db_name: str = ""
+
+    @model_validator(mode="after")  # type: ignore
+    def default_input_db_name(self) -> "AmpelConfig":
+        if not self.input_mongo_db_name:
+            self.input_mongo_db_name = self.mongo_db_name + "_input"
+        return self
 
     def build_interface(self, original_id_key: str, input_csv: Path) -> AmpelInterface:
         return AmpelInterface(

{timewise-1.0.0a1 → timewise-1.0.0a2}/timewise/process/stacking.py

@@ -26,6 +26,8 @@ def calculate_epochs(
     visit_mask: npt.NDArray[np.int64],
     counts: npt.NDArray[np.int64],
     remove_outliers: bool,
+    outlier_threshold: float,
+    outlier_quantile: float,
     outlier_mask: npt.NDArray[np.bool_] | None = None,
 ) -> tuple[
     npt.NDArray[np.float64],
@@ -70,7 +72,7 @@ def calculate_epochs(
     # ---------------------   remove outliers in the bins   ---------------------- #
 
     # if we do not want to clean outliers just set the threshold to infinity
-    outlier_thresh = np.inf if not remove_outliers else 20
+    _outlier_threshold = np.inf if not remove_outliers else outlier_threshold
 
     # set up empty masks
     outlier_mask = cast(
@@ -156,15 +158,16 @@ def calculate_epochs(
         # take the maximum value of the measured single exposure errors and the standard deviation
         u = np.maximum(std, e_meas)
 
-        # calculate 90% confidence interval
-        u70 = np.zeros_like(counts, dtype=float)
-        u70[one_points_mask] = 1e-10
+        # Estimate the spread of the flux.
+        # To be robust against outliers, do that with quantiles instead of std
+        qs = np.zeros_like(counts, dtype=float)
+        qs[one_points_mask] = 1e-10
         visits_at_least_two_point = np.unique(visit_mask[~one_points_mask[visit_mask]])
-        u70[visits_at_least_two_point] = np.array(
+        qs[visits_at_least_two_point] = np.array(
             [
                 np.quantile(
                     abs(f[(visit_mask == i) & use_mask] - median[i]),
-                    0.7,
+                    outlier_quantile,
                     method="interpolated_inverted_cdf",
                 )
                 for i in visits_at_least_two_point
@@ -173,7 +176,7 @@ def calculate_epochs(
 
         # ---------------------   remove outliers in the bins   ---------------------- #
         remaining_outliers = (
-            abs(median[visit_mask] - f) > outlier_thresh * u70[visit_mask]
+            abs(median[visit_mask] - f) > _outlier_threshold * qs[visit_mask]
         ) & ~outlier_mask
         outlier_mask |= remaining_outliers
         n_remaining_outlier = sum(remaining_outliers) if remove_outliers else 0
@@ -187,7 +190,12 @@ def calculate_epochs(
     return median, u, bin_ulim_bool, outlier_mask, use_mask, n_points
 
 
-def stack_visits(lightcurve: pd.DataFrame, clean_outliers: bool = True):
+def stack_visits(
+    lightcurve: pd.DataFrame,
+    outlier_threshold: float,
+    outlier_quantile: float,
+    clean_outliers: bool = True,
+):
     """
     Combine the data by visits of the satellite of one region in the sky.
     The visits typically consist of some tens of observations. The individual visits are separated by about
@@ -204,7 +212,7 @@ def stack_visits(lightcurve: pd.DataFrame, clean_outliers: bool = True):
     """
 
     # -------------------------   create visit mask   -------------------------- #
-    visit_map = get_visit_map(lightcurve)
+    visit_map = get_visit_map(lightcurve.mjd)
     counts = np.bincount(visit_map)
 
     stacked_data: Dict[str, Any] = dict()
@@ -235,6 +243,8 @@ def stack_visits(lightcurve: pd.DataFrame, clean_outliers: bool = True):
                 counts,
                 remove_outliers=remove_outliers,
                 outlier_mask=outlier_mask,
+                outlier_quantile=outlier_quantile,
+                outlier_threshold=outlier_threshold,
             )
             n_outliers = np.sum(outlier_mask)
 
@@ -300,6 +310,8 @@ def stack_visits(lightcurve: pd.DataFrame, clean_outliers: bool = True):
                 counts,
                 remove_outliers=False,
                 outlier_mask=outlier_masks[keys.FLUX_EXT],
+                outlier_threshold=outlier_threshold,
+                outlier_quantile=outlier_quantile,
             )
         )
         stacked_data[f"{b}{keys.MEAN}{keys.FLUX_DENSITY_EXT}"] = mean_fd

{timewise-1.0.0a1 → timewise-1.0.0a2}/timewise/util/visits.py

@@ -3,31 +3,31 @@ import pandas as pd
 import numpy.typing as npt
 
 
-def get_visit_map(lightcurve: pd.DataFrame) -> npt.NDArray[np.int64]:
+def get_visit_map(
+    mjd: npt.NDArray[np.float64] | pd.Series,
+) -> npt.NDArray[np.int64]:
     """
     Create a map datapoint to visit
 
-    :param lightcurve: the raw lightcurve
-    :type lightcurve: pd.DataFrame
+    :param mjd: the MJDs of the observations
+    :type mjd: npt.NDArray[float]
     :returns: visit map
     :rtype: npt.ArrayLike
     """
     # -------------------------   find epoch intervals   -------------------------- #
-    sorted_mjds = np.sort(lightcurve.mjd)
+    sorted_mjds = np.sort(mjd)
     epoch_bounds_mask = (sorted_mjds[1:] - sorted_mjds[:-1]) > 100
     epoch_bins = np.array(
-        [
-            lightcurve.mjd.min() * 0.99
-        ]  # this makes sure that the first datapoint gets selected
+        [mjd.min() * 0.99]  # this makes sure that the first datapoint gets selected
         + list(
             ((sorted_mjds[1:] + sorted_mjds[:-1]) / 2)[epoch_bounds_mask]
         )  # finding the middle between
         +
         # two visits
         [
-            lightcurve.mjd.max() * 1.01
+            mjd.max() * 1.01
         ]  # this just makes sure that the last datapoint gets selected as well
     )
 
-    visit_mask = np.digitize(lightcurve.mjd, epoch_bins) - 1
+    visit_mask = np.digitize(mjd, epoch_bins) - 1
     return visit_mask

timewise-1.0.0a1/timewise/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.0.0a1"