isgri 0.6.1__py3-none-any.whl → 0.7.1__py3-none-any.whl

isgri/utils/file_loaders.py

@@ -43,18 +43,103 @@ from numpy.typing import NDArray
 from typing import Tuple, Dict, Optional, Union
 from pathlib import Path
 import os
-from .pif import apply_pif_mask, coding_fraction, estimate_active_modules
+from .pif import coding_fraction, estimate_active_modules
+from ..config import Config
 
 
-def verify_events_path(path: Union[str, Path]) -> str:
+def resolve_pif_path(
+    pif_path: Optional[Union[str, Path]] = None,
+    source: Optional[str] = None,
+    swid: Optional[str] = None,
+    config: Optional[Config] = None,
+) -> str:
+    """
+    Resolve PIF file path based on input or source name.
+
+    Parameters
+    ----------
+    pif_path : str or Path, optional
+        Direct path to PIF file.
+    source : str, optional
+        Source name to construct default PIF path.
+    swid : str, optional
+        Science Window ID
+    config : Config, optional
+        Configuration object containing pif_path.
+
+    Returns
+    -------
+    resolved_path : str
+        Resolved absolute path to PIF file.
+
+    Raises
+    ------
+    FileNotFoundError
+        If PIF file not found.
+
+    Notes
+    -----
+    - If both pif_path and source are provided, pif_path takes precedence.
+    - If neither is provided, raises ValueError.
+    """
+    if pif_path is not None:
+        path = Path(pif_path)
+        if path.is_file():
+            return str(path)
+        if not path.is_dir():
+            raise FileNotFoundError(f"PIF path is not a directory: {path}")
+
+    elif config is not None and config.pif_path is not None:
+        path = Path(config.pif_path)
+        if not path.is_dir():
+            raise FileNotFoundError(f"PIF path from config is not a directory: {path}")
+    else:
+        raise ValueError("Either pif_path must be provided here or in config.")
+
+    if swid is None:
+        raise ValueError("swid must be provided to resolve PIF file name.")
+
+    if source is not None:
+        candidate_path = path / source
+        if candidate_path.is_dir():
+            path = candidate_path
+
+    revol = swid[:4]
+    revol_dir = path / revol
+    if revol_dir.is_dir():
+        path = revol_dir
+
+    candidate_files = [f for f in os.listdir(path) if f.startswith(swid)]
+    if len(candidate_files) == 0:
+        raise FileNotFoundError(f"No PIF file found for SWID {swid} in directory: {path}")
+    elif len(candidate_files) > 1:
+        raise FileNotFoundError(
+            f"Multiple PIF files found for SWID {swid} in directory: {path}\n"
+            f"Found: {candidate_files}\n"
+            "Please specify the exact file path."
+        )
+    resolved_path = path / candidate_files[0]
+    if not resolved_path.is_file():
+        raise FileNotFoundError(f"PIF file not found: {resolved_path}")
+
+    return str(resolved_path)
+
+
+def resolve_event_path(
+    events_path: Optional[Union[str, Path]] = None, swid: Optional[str] = None, config: Optional[Config] = None
+) -> str:
     """
     Verify and resolve the events file path.
 
     Parameters
     ----------
-    path : str or Path
+    events_path : str or Path, optional
         File path or directory path containing events file.
         If directory, searches for files containing 'isgri_events'.
+    swid : str, optional
+        Science Window ID to construct default event path. Requires events_path to be None and defined archive_path in Config.
+    config : Config, optional
+        Configuration object containing archive_path.
 
     Returns
     -------
@@ -80,16 +165,34 @@ def verify_events_path(path: Union[str, Path]) -> str:
     >>> # Will raise error if multiple files
     >>> verify_events_path("/data/scw/")  # Multiple SCWs present
     FileNotFoundError: Multiple isgri_events files found...
+
+    Notes
+    -----
+    - If both events_path and swid are provided, events_path takes precedence.
+    - If neither is provided, raises ValueError.
+    - Using swid requires archive_path in Config and constructs path as:
+      {archive_path}/{revol}/{swid}/isgri_events.fits.gz
     """
-    path = Path(path)
+    if events_path is not None:
+        path = Path(events_path)
+        if path.is_file():
+            return verify_events_file(path)
+        elif not path.is_dir():
+            raise FileNotFoundError(f"Events path does not exist: {path}")
+    elif config is not None and swid is not None:
+        if config.archive_path is None:
+            raise ValueError("archive_path must be defined in config to resolve events path using swid.")
+        path = Path(config.archive_path)
+        if not path.is_dir():
+            raise FileNotFoundError(f"Archive path from config is not a directory: {path}")
+    else:
+        raise ValueError("Either events_path must be provided here or in config along with swid.")
 
-    if path.is_file():
-        resolved_path = str(path)
-    elif path.is_dir():
+    if swid is None:
         candidate_files = [f for f in os.listdir(path) if "isgri_events" in f]
-
-        if len(candidate_files) == 0:
-            raise FileNotFoundError(f"No isgri_events file found in directory: {path}")
+        if len(candidate_files) == 1:
+            resolved_path = path / candidate_files[0]
+            return verify_events_file(resolved_path)
         elif len(candidate_files) > 1:
             raise FileNotFoundError(
                 f"Multiple isgri_events files found in directory: {path}\n"
@@ -97,21 +200,68 @@ def verify_events_path(path: Union[str, Path]) -> str:
                 "Please specify the exact file path."
             )
         else:
-            resolved_path = str(path / candidate_files[0])
+            raise FileNotFoundError(f"No isgri_events file found in directory: {path}")
+
+    revol = swid[:4]
+    revol_dir = path / revol
+    if revol_dir.is_dir():
+        path = revol_dir
+    candidate_dirs = [d for d in os.listdir(path) if d.startswith(swid) and (path / d).is_dir()]
+    if len(candidate_dirs) == 1:
+        path = path / candidate_dirs[0]
+    elif len(candidate_dirs) > 1:
+        raise FileNotFoundError(
+            f"Multiple directories found for SWID {swid} in directory: {path}\n"
+            f"Found: {candidate_dirs}\n"
+            "Please specify the exact file path."
+        )
+    else:
+        raise FileNotFoundError(f"No directory found for SWID {swid} in directory: {path}")
+
+    candidate_files = [f for f in os.listdir(path) if "isgri_events" in f]
+
+    if len(candidate_files) == 0:
+        raise FileNotFoundError(f"No isgri_events file found in directory: {path}")
+    elif len(candidate_files) > 1:
+        raise FileNotFoundError(
+            f"Multiple isgri_events files found in directory: {path}\n"
+            f"Found: {candidate_files}\n"
+            "Please specify the exact file path."
+        )
     else:
-        raise FileNotFoundError(f"Path does not exist: {path}")
+        resolved_path = str(path / candidate_files[0])
+
+    return verify_events_file(resolved_path)
+
+
+def verify_events_file(events_path: Union[str, Path]) -> str:
+    """
+    Verify that the provided events file path is valid.
+    Parameters
+    ----------
+    events_path : str or Path
+        Path to events FITS file.
+    Returns
+    -------
+    str
+        Validated absolute path to events FITS file.
+    Raises
+    ------
+    FileNotFoundError
+        If events file not found.
+    ValueError
+        If required FITS extension missing.
+    """
 
-    # Verify FITS structure
     try:
-        with fits.open(resolved_path) as hdu:
+        with fits.open(events_path) as hdu:
             if "ISGR-EVTS-ALL" not in hdu:
-                raise ValueError(f"Invalid events file: ISGR-EVTS-ALL extension not found in {resolved_path}")
+                raise ValueError(f"Invalid events file: ISGR-EVTS-ALL extension not found in {events_path}")
     except Exception as e:
         if isinstance(e, (FileNotFoundError, ValueError)):
             raise
-        raise ValueError(f"Cannot open FITS file {resolved_path}: {e}")
-
-    return resolved_path
+        raise ValueError(f"Cannot open FITS file {events_path}: {e}")
+    return str(events_path)
 
 
 def load_isgri_events(events_path: Union[str, Path]) -> Tuple[Table, NDArray[np.float64], Dict]:
@@ -165,9 +315,8 @@ def load_isgri_events(events_path: Union[str, Path]) -> Tuple[Table, NDArray[np.
     --------
     load_isgri_pif : Apply detector response weighting
     """
-    confirmed_path = verify_events_path(events_path)
 
-    with fits.open(confirmed_path) as hdu:
+    with fits.open(events_path) as hdu:
         # Load events
         events_data = hdu["ISGR-EVTS-ALL"].data
         header = hdu["ISGR-EVTS-ALL"].header
@@ -281,7 +430,6 @@ def merge_metadata(events_metadata: Dict, pif_metadata: Dict) -> Dict:
 def load_isgri_pif(
     pif_path: Union[str, Path],
     events: Table,
-    pif_threshold: float = 0.5,
     pif_extension: int = -1,
 ) -> Tuple[Table, NDArray[np.float64], Dict]:
     """
@@ -296,9 +444,6 @@ def load_isgri_pif(
         Path to PIF FITS file.
     events : Table
         Events table from load_isgri_events() with DETZ, DETY columns.
-    pif_threshold : float, default 0.5
-        Minimum PIF value to keep event (0.0-1.0).
-        Higher values = only well-illuminated pixels.
     pif_extension : int, default -1
         FITS extension index containing PIF data.
         -1 = last extension (typical).
@@ -352,12 +497,8 @@ def load_isgri_pif(
     See Also
     --------
     load_isgri_events : Load event data
-    apply_pif_mask : Apply PIF filtering
     coding_fraction : Calculate coded fraction
     """
-    if not (0 <= pif_threshold <= 1):
-        raise ValueError(f"pif_threshold must be in [0, 1], got {pif_threshold}")
-
     pif_path = Path(pif_path)
     if not pif_path.exists():
         raise FileNotFoundError(f"PIF file not found: {pif_path}")
@@ -387,6 +528,6 @@ def load_isgri_pif(
     pif_metadata["No_Modules"] = estimate_active_modules(pif_file)
 
     # Apply PIF mask
-    filtered_events, pif_weights = apply_pif_mask(pif_file, events, pif_threshold)
+    pif_weights = pif_file[events["DETZ"], events["DETY"]]
 
-    return filtered_events, pif_weights, pif_metadata
+    return events, pif_weights, pif_metadata

isgri/utils/lightcurve.py

@@ -32,8 +32,16 @@ from numpy.typing import NDArray
 from typing import Optional, Union, Tuple, List
 from pathlib import Path
 import os
-from .file_loaders import load_isgri_events, load_isgri_pif, default_pif_metadata, merge_metadata
+from .file_loaders import (
+    resolve_event_path,
+    load_isgri_events,
+    resolve_pif_path,
+    load_isgri_pif,
+    default_pif_metadata,
+    merge_metadata,
+)
 from .pif import DETZ_BOUNDS, DETY_BOUNDS
+from ..config import Config
 
 
 class LightCurve:
@@ -103,7 +111,9 @@ class LightCurve:
         detz: NDArray[np.float64],
         weights: NDArray[np.float64],
         metadata: dict,
-    ) -> None:
+        use_pif: bool = True,
+        pif_threshold: float = 0.5,
+    ):
         """
         Initialize LightCurve instance.
 
@@ -133,14 +143,19 @@ class LightCurve:
         self.detz = detz
         self.weights = weights
         self.metadata = metadata
+        self.use_pif = bool(use_pif and np.any(weights != 1.0))
+        self.pif_threshold = pif_threshold
+        self._cached_weights = None
+        self._cached_pif_settings = (self.use_pif, self.pif_threshold)
 
     @classmethod
     def load_data(
         cls,
         events_path: Optional[Union[str, Path]] = None,
         pif_path: Optional[Union[str, Path]] = None,
-        scw: Optional[str] = None,
+        swid: Optional[str] = None,
         source: Optional[str] = None,
+        use_pif: bool = True,
         pif_threshold: float = 0.5,
         pif_extension: int = -1,
     ) -> "LightCurve":
@@ -150,7 +165,7 @@ class LightCurve:
         Args:
             events_path (str): The path to the events file or directory.
             pif_path (str, optional): The path to the PIF file. Defaults to None.
-            scw (str, optional): SCW identifier for auto-path resolution. Defaults to None.
+            swid (str, optional): Science Window ID for auto-path resolution. Defaults to None.
             source (str, optional): Source name for auto-path resolution. Defaults to None.
             pif_threshold (float, optional): The PIF threshold value. Defaults to 0.5.
             pif_extension (int, optional): PIF file extension index. Defaults to -1.
@@ -158,12 +173,18 @@ class LightCurve:
         Returns:
             LightCurve: An instance of the LightCurve class.
         """
-        events, gtis, metadata = load_isgri_events(events_path)
-        if pif_path:
+        if swid is not None or source is not None:
+            cfg = Config()
+        else:
+            cfg = None
+
+        confirmed_events_path = resolve_event_path(events_path, swid, cfg)
+        events, gtis, metadata = load_isgri_events(confirmed_events_path)
+        if pif_path is not None or source is not None:
             if pif_threshold < 0 or pif_threshold > 1:
                 raise ValueError(f"pif_threshold must be in [0, 1], got {pif_threshold}")
-            
-            events, weights, metadata_pif = load_isgri_pif(pif_path, events, pif_threshold, pif_extension)
+            pif_path = resolve_pif_path(pif_path, source, metadata["SWID"], cfg)
+            events, weights, metadata_pif = load_isgri_pif(pif_path, events, pif_extension)
         else:
             weights = np.ones(len(events))
             metadata_pif = default_pif_metadata()
@@ -172,7 +193,7 @@ class LightCurve:
         time = events["TIME"]
         energies = events["ISGRI_ENERGY"]
         dety, detz = events["DETY"], events["DETZ"]
-        return cls(time, energies, gtis, dety, detz, weights, metadata)
+        return cls(time, energies, gtis, dety, detz, weights, metadata, use_pif, pif_threshold)
 
     def rebin(
         self,
@@ -181,6 +202,8 @@ class LightCurve:
         emax: float,
         local_time: bool = True,
         custom_mask: Optional[NDArray[np.bool_]] = None,
+        use_pif: Optional[bool] = None,
+        pif_threshold: Optional[float] = None,
     ) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
         """
         Rebins the events with the specified bin size and energy range.
@@ -224,10 +247,13 @@ class LightCurve:
         # Create bins
         bins, binsize_actual = self._create_bins(binsize, time, t0, local_time)
 
+        # Get weights
+        weights = self._get_weights(use_pif, pif_threshold)
+
         # Apply filters
         mask = self._create_event_mask(emin, emax, custom_mask)
         time_filtered = time[mask]
-        weights_filtered = self.weights[mask]
+        weights_filtered = weights[mask]
 
         # Histogram
         counts, bin_edges = np.histogram(time_filtered, bins=bins, weights=weights_filtered)
@@ -265,6 +291,42 @@ class LightCurve:
 
         return bins, binsize_actual
 
+    def _get_weights(
+        self, use_pif: Optional[bool] = None, pif_threshold: Optional[float] = None
+    ) -> NDArray[np.float64]:
+        """
+        Get event weights based on PIF settings.
+
+        Parameters
+        ----------
+        use_pif : bool, optional
+            Override instance use_pif setting
+        pif_threshold : float, optional
+            Override instance pif_threshold setting
+
+        Returns
+        -------
+        weights : ndarray
+            Event weights (0 if below threshold, PIF value otherwise, or 1.0 if no PIF)
+        """
+        if use_pif is None:
+            use_pif = self.use_pif
+        if pif_threshold is None:
+            pif_threshold = self.pif_threshold
+
+        cache_key = (use_pif, pif_threshold)
+        if cache_key == self._cached_pif_settings and self._cached_weights is not None:
+            return self._cached_weights
+
+        if not use_pif:
+            weights = np.ones_like(self.weights)
+        else:
+            weights = np.where(self.weights > pif_threshold, self.weights, 0.0)
+
+        self._cached_pif_settings = cache_key
+        self._cached_weights = weights
+        return weights
+
     def _create_event_mask(
         self,
         emin: float,
@@ -298,6 +360,8 @@ class LightCurve:
         emax: float,
         local_time: bool = True,
         custom_mask: Optional[NDArray[np.bool_]] = None,
+        use_pif: Optional[bool] = None,
+        pif_threshold: Optional[float] = None,
     ) -> Tuple[NDArray[np.float64], List[NDArray[np.float64]]]:
         """
         Rebins the events by all 8 detector modules with the specified bin size and energy range.
@@ -337,7 +401,9 @@ class LightCurve:
         time_filtered = time[energy_mask]
         dety_filtered = self.dety[energy_mask]
         detz_filtered = self.detz[energy_mask]
-        weights_filtered = self.weights[energy_mask]
+
+        weights = self._get_weights(use_pif, pif_threshold)
+        weights_filtered = weights[energy_mask]
 
         # Compute module indices using digitize
         dety_bin = np.digitize(dety_filtered, DETY_BOUNDS) - 1  # 0 or 1
@@ -358,6 +424,8 @@ class LightCurve:
         emin: float,
         emax: float,
         local_time: bool = True,
+        use_pif: Optional[bool] = None,
+        pif_threshold: Optional[float] = None,
     ) -> float:
         """
         Calculates the counts in the specified time and energy range.
@@ -373,7 +441,29 @@ class LightCurve:
             float: The total counts in the specified range.
         """
         time = self.local_time if local_time else self.time
-        return np.sum(self.weights[(time >= t1) & (time < t2) & (self.energies >= emin) & (self.energies < emax)])
+        weights = self._get_weights(use_pif, pif_threshold)
+        return np.sum(weights[(time >= t1) & (time < t2) & (self.energies >= emin) & (self.energies < emax)])
+
+    def get(
+        self, use_pif: Optional[bool] = None, pif_threshold: Optional[float] = None
+    ) -> Tuple[
+        NDArray[np.float64], NDArray[np.float64], NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]
+    ]:
+        """
+        Returns the time, energies, dety, detz, weights arrays with filtering above PIF threshold applied.
+        Args:
+            use_pif (bool, optional): Override instance use_pif setting
+            pif_threshold (float, optional): Override instance pif_threshold setting
+        """
+        weights = self._get_weights(use_pif, pif_threshold)
+        mask = weights > 0.0
+        return (
+            self.time[mask],
+            self.energies[mask],
+            self.dety[mask],
+            self.detz[mask],
+            weights[mask],
+        )
 
     def ijd2loc(self, ijd_time: Union[float, NDArray[np.float64]]) -> Union[float, NDArray[np.float64]]:
         """
@@ -405,5 +495,5 @@ class LightCurve:
             f"LightCurve(n_events={len(self.time)}, "
             f"time_range=({self.time[0]:.3f}, {self.time[-1]:.3f}) IJD, "
             f"energy_range=({self.energies.min():.1f}, {self.energies.max():.1f}) keV, "
-            f"scw={self.metadata.get('SWID', 'Unknown')})"
+            f"scw={self.metadata.get('SWID', 'Unknown')}), use_pif={self.use_pif}, pif_threshold={self.pif_threshold})"
         )

isgri/utils/pif.py

@@ -36,6 +36,7 @@ import numpy as np
 from numpy.typing import NDArray
 from typing import Tuple
 from astropy.table import Table
+import warnings
 
 # ISGRI detector module boundaries (mm coordinates)
 # 8 modules total: 4 rows × 2 columns
@@ -99,9 +100,16 @@ def apply_pif_mask(
     events: Table,
     pif_threshold: float = 0.5,
 ) -> Tuple[Table, NDArray[np.float64]]:
+    
     """
     Filter events by PIF threshold and return PIF weights.
 
+    .. deprecated:: 
+        This function is deprecated. PIF filtering is now handled
+        automatically by LightCurve methods using the `use_pif` and
+        `pif_threshold` attributes. Use `LightCurve.load_data()` instead.
+
+
     Events with PIF < threshold are removed. Remaining events are
     weighted by their PIF values for response correction.
 
@@ -138,6 +146,12 @@ def apply_pif_mask(
     >>> print(f"Kept {len(filtered)}/{len(events)} events")
     >>> print(f"Mean weight: {weights.mean():.3f}")
     """
+    warnings.warn(
+        "apply_pif_mask() is deprecated. Use LightCurve.load_data() with "
+        "use_pif and pif_threshold parameters instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     # Validate inputs
     if not (0 <= pif_threshold <= 1):
         raise ValueError(f"pif_threshold must be in [0, 1], got {pif_threshold}")

isgri/utils/quality.py

@@ -366,9 +366,10 @@ class QualityMetrics:
             time, counts = data["time"], data["counts"]
 
         if gtis is None:
-            if self.lightcurve is None:
-                raise ValueError("Must provide gtis or set lightcurve")
-            gtis = self.lightcurve.gtis
+            if self.lightcurve is not None:
+                gtis = self.lightcurve.gtis
+        if gtis is None or len(gtis) == 0:
+            raise ValueError("GTIs must be provided or available in lightcurve")
 
         # Check for overlap
         if gtis[0, 0] > time[-1] or gtis[-1, 1] < time[0]: