- Removed noise_group as a property and simplified it as an integer attribute.

- Introduced new bounding box attributes (`bbox_wl`, `bbox_tm`) and respective min/max calculations for wavelength and time.
- Adjusted logic to use `bbox_wl` for wavelength bounds in relevant functions.
- Removed redundant `_update_nids` and associated properties/methods for noise group handling.
- Simplified imports in `exoiris.py` by removing unused items.

Author: hpparvi

exoiris/exoiris.py

@@ -24,20 +24,17 @@
 
 import astropy.io.fits as pf
 import astropy.units as u
-import emcee
+import matplotlib.axes
 import pandas as pd
-import pytransit.utils.de
-import seaborn as sb
 from astropy.table import Table
 from celerite2 import GaussianProcess, terms
 from emcee import EnsembleSampler
 from matplotlib.pyplot import subplots, setp, figure, Figure, Axes
 from numpy import (any, where, sqrt, clip, percentile, median, squeeze, floor, ndarray, isfinite,
-                   array, inf, newaxis, arange, tile, sort, argsort, concatenate, full, nan, r_, nanpercentile, log10,
+                   array, inf, arange, argsort, concatenate, full, nan, r_, nanpercentile, log10,
                    ceil, unique)
-from numpy.random import normal, permutation
+from numpy.random import normal
 from pytransit import UniformPrior, NormalPrior
-from pytransit.orbits import epoch
 from pytransit.param import ParameterSet
 from pytransit.utils.de import DiffEvol
 from scipy.stats import norm

exoiris/tsdata.py

@@ -108,13 +108,17 @@ def __init__(self, time: Sequence, wavelength: Sequence, fluxes: Sequence, error
         self.fluxes: ndarray = where(self.mask, fluxes, nan)
         self.errors: ndarray = where(self.mask, errors, nan)
         self.transit_mask: ndarray = transit_mask if transit_mask is not None else ones(time.size, dtype=bool)
-        self.ngid: int = 0
         self._ephemeris: Ephemeris | None = ephemeris
         self.n_baseline: int = n_baseline
-        self._noise_group: str = noise_group
+        self.noise_group: int = noise_group
         self.epoch_group: int = epoch_group
         self.offset_group: int = offset_group
         self._dataset: Optional['TSDataSet'] = None
+        self.minwl: float = 0.0
+        self.maxwl: float = inf
+        self.mintm: float = 0.0
+        self.maxtm: float = inf
+
         self._update()
 
         if wl_edges is None:
@@ -204,17 +208,6 @@ def import_fits(name: str, hdul: pf.HDUList) -> 'TSData':
     def __repr__(self) -> str:
         return f"TSData Name:'{self.name}' [{self.wavelength[0]:.2f} - {self.wavelength[-1]:.2f}] nwl={self.nwl} npt={self.npt}"
 
-    @property
-    def noise_group(self) -> str:
-        """Noise group name."""
-        return self._noise_group
-
-    @noise_group.setter
-    def noise_group(self, ng: str) -> None:
-        self._noise_group = ng
-        if self._dataset is not None:
-            self._dataset._update_nids()
-
     @property
     def ephemeris(self) -> Ephemeris:
         """Ephemeris."""
@@ -225,6 +218,15 @@ def ephemeris(self, ep: Ephemeris) -> None:
         self._ephemeris = ep
         self.mask_transit(ephemeris=ep)
 
+    @property
+    def bbox_wl(self) -> tuple[float, float]:
+        """Wavelength bounds of the bounding box."""
+        return self.minwl, self.maxwl
+
+    @property
+    def bbox_tm(self) -> tuple[float, float]:
+        return self.mintm, self.maxtm
+
     def mask_transit(self, t0: float | None = None, p: float | None = None, t14: float | None = None,
                      ephemeris : Ephemeris | None = None, elims: tuple[int, int] | None = None) -> 'TSData':
         """Create a transit mask based on a given ephemeris or exposure index limits.
@@ -274,7 +276,10 @@ def _update(self) -> None:
         """Update the internal attributes."""
         self.nwl = self.wavelength.size
         self.npt = self.time.size
-        self.wllims = self.wavelength.min(), self.wavelength.max()
+        self.minwl = self.wavelength.min()
+        self.maxwl = self.wavelength.max()
+        self.mintm = self.time.min()
+        self.maxtm = self.time.max()
         if self._ephemeris is not None:
             self.mask_transit(ephemeris=self._ephemeris)
 
@@ -650,7 +655,7 @@ def bin_wavelength(self, binning: Optional[Union[Binning, CompoundBinning]] = No
         with warnings.catch_warnings():
             warnings.simplefilter('ignore', numba.NumbaPerformanceWarning)
             if binning is None:
-                binning = Binning(self.wllims[0], self.wllims[1], nb=nb, bw=bw, r=r)
+                binning = Binning(self.bbox_wl[0], self.bbox_wl[1], nb=nb, bw=bw, r=r)
             bf, be = bin2d(self.fluxes, self.errors, self._wl_l_edges, self._wl_r_edges,
                            binning.bins, estimate_errors=estimate_errors)
             if not all(isfinite(be)):
@@ -726,19 +731,11 @@ def _add_data(self, d: TSData) -> None:
             raise ValueError('A TSData object with the same name already exists.')
         d._dataset = self
         self.data.append(d)
-        self._update_nids()
         self.wlmin = min(self.wlmin, d.wavelength.min())
         self.wlmax = max(self.wlmax, d.wavelength.max())
         self.tmin = min(self.tmin, d.time.min())
         self.tmax = max(self.tmax, d.time.max())
 
-    def _update_nids(self):
-        ngs =  pd.Categorical(self.noise_groups)
-        self.unique_noise_groups = list(ngs.categories)
-        self.ngids = ngs.codes.astype(int)
-        for i,d in enumerate(self.data):
-            d.ngid = self.ngids[i]
-
     @property
     def names(self) -> list[str]:
         """List of data set names."""
@@ -765,7 +762,7 @@ def errors(self) -> list[ndarray]:
         return [d.errors for d in self.data]
 
     @property
-    def noise_groups(self) -> list[str]:
+    def noise_groups(self) -> list[int]:
         """List of noise group names."""
         return [d.noise_group for d in self.data]