isgri 0.1.0__py3-none-any.whl

isgri/utils/__init__.py

@@ -0,0 +1,5 @@
+from .lightcurve import LightCurve
+from .time_conversion import ijd2utc, utc2ijd
+from .quality import QualityMetrics
+
+__all__ = ["LightCurve", "ijd2utc", "utc2ijd", "QualityMetrics"]

isgri/utils/file_loaders.py

@@ -0,0 +1,159 @@
+from astropy.io import fits
+from .pif import apply_pif_mask, coding_fraction, estimate_active_modules
+import numpy as np
+import os
+
+
+def verify_events_path(path):
+    """
+    Verifies and resolves the events file path.
+
+    Args:
+        path (str): File path or directory path containing events file.
+
+    Returns:
+        str: Resolved path to valid events file.
+
+    Raises:
+        FileNotFoundError: If path doesn't exist, no events file found, or multiple events files found.
+        ValueError: If ISGR-EVTS-ALL extension not found in file.
+
+    """
+    if os.path.isfile(path):
+        resolved_path = path
+    elif os.path.isdir(path):
+        candidate_files = [f for f in os.listdir(path) if "isgri_events" in f]
+        if len(candidate_files) == 0:
+            raise FileNotFoundError("No isgri_events file found in the provided directory.")
+        elif len(candidate_files) > 1:
+            raise FileNotFoundError(
+                f"Multiple isgri_events files found in the provided directory: {path}.",
+                "\nPlease specify the exact file paths.",
+            )
+        else:
+            resolved_path = os.path.join(path, candidate_files[0])
+    else:
+        raise FileNotFoundError(f"Path does not exist: {path}")
+
+    with fits.open(resolved_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}")
+    return resolved_path
+
+
+def load_isgri_events(events_path):
+    """
+    Loads ISGRI events from FITS file.
+
+    Args:
+        events_path (str): Path to events file or directory.
+
+    Returns:
+        tuple: (events, gtis, metadata) where:
+            - events: Structured numpy array with TIME, ISGRI_ENERGY, DETY, DETZ fields
+            - gtis: (N, 2) array of Good Time Interval [start, stop] pairs (IJD)
+            - metadata: Dictionary with header info (REVOL, SWID, TSTART, etc.)
+
+    """
+    confirmed_path = verify_events_path(events_path)
+    with fits.open(confirmed_path) as hdu:
+        events = np.array(hdu["ISGR-EVTS-ALL"].data)
+        header = hdu["ISGR-EVTS-ALL"].header
+        metadata = {
+            "REVOL": header.get("REVOL"),
+            "SWID": header.get("SWID"),
+            "TSTART": header.get("TSTART"),
+            "TSTOP": header.get("TSTOP"),
+            "TELAPSE": header.get("TELAPSE"),
+            "OBT_TSTART": header.get("OBTSTART"),
+            "OBT_TSTOP": header.get("OBTEND"),
+            "RA_SCX": header.get("RA_SCX"),
+            "DEC_SCX": header.get("DEC_SCX"),
+            "RA_SCZ": header.get("RA_SCZ"),
+            "DEC_SCZ": header.get("DEC_SCZ"),
+        }
+        try:
+            gtis = np.array(hdu["IBIS-GNRL-GTI"].data)
+            gtis = np.array([gtis["START"], gtis["STOP"]]).T
+        except:
+            gtis = np.array([events["TIME"][0], events["TIME"][-1]]).reshape(1, 2)
+    events = events[events["SELECT_FLAG"] == 0]  # Filter out bad events
+    return events, gtis, metadata
+
+
+def default_pif_metadata():
+    """
+    Creates default PIF metadata dictionary for cases without PIF file.
+
+    Returns:
+        dict: Default PIF metadata with all 8 modules active, no source info.
+    """
+    return {
+        "SWID": None,
+        "SRC_RA": None,
+        "SRC_DEC": None,
+        "Source_Name": None,
+        "cod": None,
+        "No_Modules": 8,
+    }
+
+
+def merge_metadata(events_metadata, pif_metadata):
+    """
+    Merges events and PIF metadata dictionaries.
+
+    Args:
+        events_metadata (dict): Metadata from events file.
+        pif_metadata (dict): Metadata from PIF file.
+
+    Returns:
+        dict: Combined metadata (PIF metadata overwrites events metadata except SWID).
+
+    """
+    merged_metadata = events_metadata.copy()
+    for key in pif_metadata:
+        if key == "SWID":
+            continue
+        merged_metadata[key] = pif_metadata[key]
+    return merged_metadata
+
+
+def load_isgri_pif(pif_path, events, pif_threshold=0.5, pif_extension=-1):
+    """
+    Loads ISGRI PIF (Pixel Illumination Fraction) file and applies mask to events.
+
+    Args:
+        pif_path (str): Path to PIF FITS file.
+        events (ndarray): Events array from load_isgri_events().
+        pif_threshold (float, optional): PIF threshold value (0-1). Defaults to 0.5.
+        pif_extension (int, optional): PIF file extension index. Defaults to -1.
+
+    Returns:
+        tuple: (piffed_events, pif, metadata_pif) where:
+            - piffed_events: Filtered events array with PIF mask applied
+            - pif: PIF values for filtered events
+            - metadata_pif: Dictionary with source info, coding fraction, active modules
+    Raises:
+        ValueError: If PIF file shape is invalid. Usually indicates empty or corrupted file.
+
+    """
+    with fits.open(pif_path) as hdu:
+        pif_file = np.array(hdu[pif_extension].data)
+        header = hdu[pif_extension].header
+
+    if pif_file.shape != (134, 130):
+        raise ValueError(f"Invalid PIF file shape: expected (134, 130), got {pif_file.shape}")
+
+    metadata_pif = {
+        "SWID": header.get("SWID"),
+        "Source_ID": header.get("SOURCEID"),
+        "Source_Name": header.get("NAME"),
+        "SRC_RA": header.get("RA_OBJ"),
+        "SRC_DEC": header.get("DEC_OBJ"),
+    }
+    metadata_pif["cod"] = coding_fraction(pif_file, events)
+    metadata_pif["No_Modules"] = estimate_active_modules(pif_file)
+
+    piffed_events, pif = apply_pif_mask(pif_file, events, pif_threshold)
+
+    return piffed_events, pif, metadata_pif

isgri/utils/lightcurve.py

@@ -0,0 +1,265 @@
+from astropy.io import fits
+import numpy as np
+import os
+from .file_loaders import load_isgri_events, load_isgri_pif, default_pif_metadata, merge_metadata
+from .pif import DETZ_BOUNDS, DETY_BOUNDS
+
+
+class LightCurve:
+    """
+    A class for working with ISGRI events. Works fully with and without ISGRI model file (PIF file).
+
+    Attributes:
+        time (ndarray): The IJD time values of the events.
+        energies (ndarray): The energy values of the events in keV.
+        gtis (ndarray): The Good Time Intervals (GTIs) of the events.
+        t0 (float): The first time of the events (IJD).
+        local_time (ndarray): The local time values of the events (seconds from t0).
+        dety (ndarray): The Y detector coordinates.
+        detz (ndarray): The Z detector coordinates.
+        pif (ndarray): The PIF values of the events.
+        metadata (dict): Event metadata including SWID, source info, etc.
+
+    Methods:
+        load_data: Loads the light curve data from events and PIF files.
+        rebin: Rebins the light curve with specified bin size and energy range.
+        rebin_by_modules: Rebins the light curve for all 8 detector modules.
+        cts: Calculates the counts in specified time and energy range.
+        ijd2loc: Converts IJD time to local time (seconds from t0).
+        loc2ijd: Converts local time to IJD time.
+    """
+
+    def __init__(self, time, energies, gtis, dety, detz, pif, metadata):
+        """
+        Initialize LightCurve instance.
+
+        Args:
+            time (ndarray): IJD time values.
+            energies (ndarray): Energy values in keV.
+            gtis (ndarray): Good Time Intervals.
+            dety (ndarray): Y detector coordinates.
+            detz (ndarray): Z detector coordinates.
+            pif (ndarray): PIF mask values.
+            metadata (dict): Event metadata.
+        """
+        self.time = time
+        self.energies = energies
+        self.gtis = gtis
+        self.t0 = time[0]
+        self.local_time = (time - self.t0) * 86400
+
+        self.dety = dety
+        self.detz = detz
+        self.pif = pif
+        self.metadata = metadata
+
+    @classmethod
+    def load_data(cls, events_path=None, pif_path=None, scw=None, source=None, pif_threshold=0.5, pif_extension=-1):
+        """
+        Loads the events from the given events file and PIF file (optional).
+
+        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.
+            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.
+
+        Returns:
+            LightCurve: An instance of the LightCurve class.
+        """
+        events, gtis, metadata = load_isgri_events(events_path)
+        if pif_path:
+            events, pif, metadata_pif = load_isgri_pif(pif_path, events, pif_threshold, pif_extension)
+        else:
+            pif = np.ones(len(events))
+            metadata_pif = default_pif_metadata()
+
+        metadata = merge_metadata(metadata, metadata_pif)
+        time = events["TIME"]
+        energies = events["ISGRI_ENERGY"]
+        dety, detz = events["DETY"], events["DETZ"]
+        return cls(time, energies, gtis, dety, detz, pif, metadata)
+
+    def rebin(self, binsize, emin, emax, local_time=True, custom_mask=None):
+        """
+        Rebins the events with the specified bin size and energy range.
+
+        Args:
+            binsize (float or array): The bin size in seconds, or array of bin edges.
+            emin (float): The minimum energy value in keV.
+            emax (float): The maximum energy value in keV.
+            local_time (bool, optional): If True, returns local time. If False, returns IJD time. Defaults to True.
+            custom_mask (ndarray, optional): Additional boolean mask to apply. Defaults to None.
+
+        Returns:
+            tuple: (time, counts) arrays.
+
+        Raises:
+            ValueError: If emin >= emax.
+
+        Examples:
+            >>> time, counts = lc.rebin(binsize=1.0, emin=30, emax=300)
+            >>> time, counts = lc.rebin(binsize=[0, 1, 2, 5, 10], emin=50, emax=200)
+        """
+        if emin >= emax:
+            raise ValueError("emin must be less than emax")
+
+        # Select time axis
+        time = self.local_time if local_time else self.time
+        t0 = 0 if local_time else self.t0
+
+        # Create bins
+        bins, binsize_actual = self._create_bins(binsize, time, t0, local_time)
+
+        # Apply filters
+        mask = self._create_event_mask(emin, emax, custom_mask)
+        time_filtered = time[mask]
+        pif_filtered = self.pif[mask]
+
+        # Histogram
+        counts, bin_edges = np.histogram(time_filtered, bins=bins, weights=pif_filtered)
+        time_centers = bin_edges[:-1] + 0.5 * binsize_actual
+
+        return time_centers, counts
+
+    def _create_bins(self, binsize, time, t0, local_time):
+        """
+        Create time bins for rebinning.
+
+        Args:
+            binsize (float or array): Bin size or custom bin edges.
+            time (ndarray): Time array.
+            t0 (float): Start time.
+            local_time (bool): Whether using local time.
+
+        Returns:
+            tuple: (bins array, actual binsize).
+        """
+        if isinstance(binsize, (list, np.ndarray)):
+            # Custom bin edges provided
+            bins = np.array(binsize)
+            binsize_actual = np.mean(np.diff(bins))
+        else:
+            # Uniform binning
+            binsize_actual = binsize if local_time else binsize / 86400
+            bins = np.arange(t0, time[-1] + binsize_actual, binsize_actual)
+
+        return bins, binsize_actual
+
+    def _create_event_mask(self, emin, emax, custom_mask=None):
+        """
+        Create combined event filter mask.
+
+        Args:
+            emin (float): Minimum energy in keV.
+            emax (float): Maximum energy in keV.
+            custom_mask (ndarray, optional): Additional mask to apply.
+
+        Returns:
+            ndarray: Boolean mask for events.
+        """
+        # Energy filter
+        mask = (self.energies >= emin) & (self.energies < emax)
+
+        # Custom filter (optional)
+        if custom_mask is not None:
+            mask &= custom_mask
+
+        return mask
+
+    def rebin_by_modules(self, binsize, emin, emax, local_time=True, custom_mask=None):
+        """
+        Rebins the events by all 8 detector modules with the specified bin size and energy range.
+
+        Args:
+            binsize (float): The bin size in seconds.
+            emin (float): The minimum energy value in keV.
+            emax (float): The maximum energy value in keV.
+            local_time (bool, optional): If True, returns local time. Defaults to True.
+            custom_mask (ndarray, optional): A custom mask to apply. Defaults to None.
+
+        Returns:
+            tuple: (times, counts) where:
+                - times: array of time bin centers
+                - counts: list of 8 arrays, one for each module
+
+        Raises:
+            ValueError: If emin >= emax.
+
+        Examples:
+            >>> times, counts = lc.rebin_by_modules(binsize=1.0, emin=30, emax=300)
+            >>> module_3_lc = counts[3]  # Get lightcurve for module 3
+        """
+        if emin >= emax:
+            raise ValueError("emin must be less than emax")
+
+        time = self.local_time if local_time else self.time
+        t0 = 0 if local_time else self.t0
+        binsize_adj = binsize if local_time else binsize / 86400
+        bins = np.arange(t0, time[-1] + binsize_adj, binsize_adj)
+        times = bins[:-1] + 0.5 * binsize_adj
+
+        energy_mask = (self.energies >= emin) & (self.energies < emax)
+        if custom_mask is not None:
+            energy_mask &= custom_mask
+
+        time_filtered = time[energy_mask]
+        dety_filtered = self.dety[energy_mask]
+        detz_filtered = self.detz[energy_mask]
+        pif_filtered = self.pif[energy_mask]
+
+        # Compute module indices using digitize
+        dety_bin = np.digitize(dety_filtered, DETY_BOUNDS) - 1  # 0 or 1
+        detz_bin = np.digitize(detz_filtered, DETZ_BOUNDS) - 1  # 0, 1, 2, or 3
+        module_idx = dety_bin + detz_bin * 2  # Flat index: 0-7
+
+        counts = []
+        for i in range(8):
+            mask = module_idx == i
+            counts.append(np.histogram(time_filtered[mask], bins=bins, weights=pif_filtered[mask])[0])
+
+        return times, counts
+
+    def cts(self, t1, t2, emin, emax, local_time=True, bkg=False):
+        """
+        Calculates the counts in the specified time and energy range.
+
+        Args:
+            t1 (float): The start time (seconds or IJD depending on local_time).
+            t2 (float): The end time (seconds or IJD depending on local_time).
+            emin (float): The minimum energy value in keV.
+            emax (float): The maximum energy value in keV.
+            local_time (bool, optional): If True, uses local time. Defaults to True.
+            bkg (bool, optional): Reserved for future background subtraction. Defaults to False.
+
+        Returns:
+            float: The total counts in the specified range.
+        """
+        time = self.local_time if local_time else self.time
+        return np.sum(self.pif[(time >= t1) & (time < t2) & (self.energies >= emin) & (self.energies < emax)])
+
+    def ijd2loc(self, ijd_time):
+        """
+        Converts IJD (INTEGRAL Julian Date) time to local time.
+
+        Args:
+            ijd_time (float or ndarray): The IJD time value(s).
+
+        Returns:
+            float or ndarray: The local time in seconds from t0.
+        """
+        return (ijd_time - self.t0) * 86400
+
+    def loc2ijd(self, evt_time):
+        """
+        Converts local time to IJD (INTEGRAL Julian Date) time.
+
+        Args:
+            evt_time (float or ndarray): The local time in seconds from t0.
+
+        Returns:
+            float or ndarray: The IJD time value(s).
+        """
+        return evt_time / 86400 + self.t0

isgri/utils/pif.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+DETZ_BOUNDS, DETY_BOUNDS = [0, 32, 66, 100, 134], [0, 64, 130]  # Detector module boundaries
+
+
+def select_isgri_module(module_no):
+    col = 0 if module_no % 2 == 0 else 1
+    row = module_no // 2
+    x1, x2 = DETZ_BOUNDS[row], DETZ_BOUNDS[row + 1]
+    y1, y2 = DETY_BOUNDS[col], DETY_BOUNDS[col + 1]
+    return x1, x2, y1, y2
+
+
+def apply_pif_mask(pif_file, events, pif_threshold=0.5):
+    pif_filter = pif_file > pif_threshold
+    piffed_events = events[pif_filter[events["DETZ"], events["DETY"]]]
+    pif = pif_file[piffed_events["DETZ"], piffed_events["DETY"]]
+    return piffed_events, pif
+
+
+def coding_fraction(pif_file, events):
+    pif_cod = pif_file == 1
+    pif_cod = events[pif_cod[events["DETZ"], events["DETY"]]]
+    cody = (np.max(pif_cod["DETY"]) - np.min(pif_cod["DETY"])) / 129
+    codz = (np.max(pif_cod["DETZ"]) - np.min(pif_cod["DETZ"])) / 133
+    pif_cod = codz * cody
+    return pif_cod
+
+
+def estimate_active_modules(mask):
+    m, n = DETZ_BOUNDS, DETY_BOUNDS  # Separate modules
+    mods = []
+    for module_no in range(8):
+        x1, x2, y1, y2 = select_isgri_module(module_no)
+        a = mask[x1:x2, y1:y2].flatten()
+        if len(a[a > 0.01]) / len(a) > 0.2:
+            mods.append(1)
+        else:
+            mods.append(0)
+    mods = np.array(mods)
+    return mods

isgri/utils/quality.py

@@ -0,0 +1,166 @@
+import numpy as np
+from .lightcurve import LightCurve
+
+
+class QualityMetrics:
+    """
+    A class for computing statistical quality metrics for ISGRI lightcurves.
+
+    Attributes:
+        lightcurve (LightCurve): The LightCurve instance to analyze.
+        binsize (float): The bin size in seconds.
+        emin (float): The minimum energy value in keV.
+        emax (float): The maximum energy value in keV.
+        local_time (bool): If True, uses local time. If False, uses IJD time. GTIs are always in IJD.
+        module_data (dict): Cached rebinned data for all modules.
+
+    Methods:
+        raw_chi_squared: Computes raw reduced chi-squared.
+        sigma_clip_chi_squared: Computes sigma-clipped reduced chi-squared.
+        gti_chi_squared: Computes GTI-filtered reduced chi-squared.
+    """
+
+    def __init__(self, lightcurve: LightCurve | None = None, binsize=1.0, emin=1.0, emax=1000.0, local_time=False):
+        """
+        Initialize QualityMetrics instance.
+
+        Args:
+            lightcurve (LightCurve, optional): The LightCurve instance to analyze. Defaults to None.
+            binsize (float, optional): The bin size in seconds. Defaults to 1.0.
+            emin (float, optional): The minimum energy value in keV. Defaults to 1.0.
+            emax (float, optional): The maximum energy value in keV. Defaults to 1000.0.
+            local_time (bool, optional): If True, uses local time. If False, uses IJD time. Defaults to False.
+
+        Raises:
+            TypeError: If lightcurve is not a LightCurve instance or None.
+        """
+        if type(lightcurve) not in [LightCurve, type(None)]:
+            raise TypeError("lightcurve must be an instance of LightCurve or None")
+        self.lightcurve = lightcurve
+        self.binsize = binsize
+        self.emin = emin
+        self.emax = emax
+        self.local_time = local_time
+        self.module_data = None
+
+    def _compute_counts(self):
+        """
+        Compute or retrieve cached rebinned counts for all modules.
+
+        Args:
+            None
+        Returns:
+            dict: Dictionary with 'time' and 'counts' arrays.
+
+        Raises:
+            ValueError: If lightcurve is not set.
+        """
+        if self.lightcurve is None:
+            raise ValueError("Lightcurve is not set.")
+        if self.module_data is not None:
+            return self.module_data
+        time, counts = self.lightcurve.rebin_by_modules(
+            binsize=self.binsize, emin=self.emin, emax=self.emax, local_time=self.local_time
+        )
+        module_data = {"time": time, "counts": counts}
+        self.module_data = module_data
+        return module_data
+
+    def _compute_chi_squared_red(self, counts, return_all=False):
+        """
+        Compute reduced chi-squared for count data.
+
+        Args:
+            counts (ndarray): Count array(s) to analyze.
+            return_all (bool, optional): If True, returns chi-squared for each array. If False, returns mean. Defaults to False.
+
+        Returns:
+            float or ndarray: Reduced chi-squared value(s).
+        """
+        counts = np.asarray(counts)
+        counts = np.where(counts == 0, np.nan, counts)
+        mean_counts = np.nanmean(counts, axis=-1, keepdims=True)
+        chi_squared = np.nansum((counts - mean_counts) ** 2 / mean_counts, axis=-1)
+        dof = counts.shape[-1] - 1
+        if return_all:
+            return chi_squared / dof
+        return np.nanmean(chi_squared / dof)
+
+    def raw_chi_squared(self, counts=None, return_all=False):
+        """
+        Computes raw reduced chi-squared for lightcurve data.
+
+        Args:
+            counts (ndarray, optional): Count array(s) to analyze. If None, uses cached module data. Defaults to None.
+            return_all (bool, optional): If True, returns chi-squared for each module. If False, returns mean. Defaults to False.
+
+        Returns:
+            float or ndarray: Reduced chi-squared value(s).
+
+        Examples:
+            >>> qm = QualityMetrics(lc, binsize=1.0, emin=30, emax=300)
+            >>> chi = qm.raw_chi_squared()
+            >>> chi_all_modules = qm.raw_chi_squared(return_all=True)
+        """
+        if counts is None:
+            counts = self._compute_counts()["counts"]
+        return self._compute_chi_squared_red(counts, return_all=return_all)
+
+    def sigma_clip_chi_squared(self, sigma=1.0, counts=None, return_all=False):
+        """
+        Computes sigma-clipped reduced chi-squared for lightcurve data.
+
+        Args:
+            sigma (float, optional): Sigma clipping threshold in standard deviations. Defaults to 1.0.
+            counts (ndarray, optional): Count array(s) to analyze. If None, uses cached module data. Defaults to None.
+            return_all (bool, optional): If True, returns chi-squared for each module. If False, returns mean. Defaults to False.
+
+        Returns:
+            float or ndarray: Reduced chi-squared value(s) after sigma clipping.
+
+        Examples:
+            >>> qm = QualityMetrics(lc, binsize=1.0, emin=30, emax=300)
+            >>> chi = qm.sigma_clip_chi_squared(sigma=3.0)
+        """
+        if counts is None:
+            counts = self._compute_counts()["counts"]
+        mean_count = np.mean(counts, axis=-1, keepdims=True)
+        std_count = np.std(counts, axis=-1, keepdims=True)
+        mask = np.abs(counts - mean_count) < sigma * std_count
+        filtered_counts = np.where(mask, counts, np.nan)
+        return self._compute_chi_squared_red(filtered_counts, return_all=return_all)
+
+    def gti_chi_squared(self, time=None, counts=None, gtis=None, return_all=False):
+        """
+        Computes GTI-filtered reduced chi-squared for lightcurve data.
+
+        Args:
+            time (ndarray, optional): Time array. If None, uses cached module data. Defaults to None.
+            counts (ndarray, optional): Count array(s) to analyze. If None, uses cached module data. Defaults to None.
+            gtis (ndarray, optional): Good Time Intervals (N, 2) array. If None, uses lightcurve GTIs. Defaults to None.
+            return_all (bool, optional): If True, returns chi-squared for each module. If False, returns mean. Defaults to False.
+
+        Returns:
+            float or ndarray: Reduced chi-squared value(s) within GTIs only.
+
+        Raises:
+            ValueError: If no overlap between GTIs and lightcurve time range.
+
+        Examples:
+            >>> qm = QualityMetrics(lc, binsize=1.0, emin=30, emax=300)
+            >>> chi = qm.gti_chi_squared()
+        """
+        if counts is None or time is None:
+            data = self._compute_counts()
+            time, counts = data["time"], data["counts"]
+        if gtis is None:
+            gtis = self.lightcurve.gtis
+        if gtis[0, 0] > time[-1] or gtis[-1, 1] < time[0]:
+            raise ValueError(
+                "No overlap between GTIs and lightcurve time. If Lightcurve is set, verify time is in IJD."
+            )
+        gti_mask = np.zeros_like(time, dtype=bool)
+        for gti_start, gti_stop in gtis:
+            gti_mask |= (time >= gti_start) & (time <= gti_stop)
+        filtered_counts = np.where(gti_mask, counts, np.nan)
+        return self._compute_chi_squared_red(filtered_counts, return_all=return_all)

isgri/utils/time_conversion.py

@@ -0,0 +1,39 @@
+from astropy.time import Time
+
+
+def ijd2utc(t):
+    """
+    Converts IJD (INTEGRAL Julian Date) time to UTC ISO format.
+
+    Args:
+        t (float or ndarray): IJD time value(s).
+
+    Returns:
+        str or ndarray: UTC time in ISO format (YYYY-MM-DD HH:MM:SS.sss).
+
+    Examples:
+        >>> ijd2utc(0.0)
+        '1999-12-31 23:58:55.817'
+        >>> ijd2utc(1000.5)
+        '2002-09-27 11:58:55.816'
+    """
+    return Time(t + 51544, format="mjd", scale="tt").utc.iso
+
+
+def utc2ijd(t):
+    """
+    Converts UTC ISO format time to IJD (INTEGRAL Julian Date).
+
+    Args:
+        t (str or ndarray): UTC time in ISO format (YYYY-MM-DD HH:MM:SS).
+
+    Returns:
+        float or ndarray: IJD time value(s).
+
+    Examples:
+        >>> utc2ijd('1999-12-31 23:58:55.817')
+        0.0
+        >>> utc2ijd('2002-09-27 00:00:00')
+        1000.0
+    """
+    return Time(t, format="iso", scale="utc").tt.mjd - 51544

isgri-0.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: isgri
+Version: 0.1.0
+Summary: Python package for INTEGRAL IBIS/ISGRI lightcurve analysis
+Author: Dominik Patryk Pacholski
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: astropy>=7.2.0
+Requires-Dist: numpy>=2.3.5
+Description-Content-Type: text/markdown
+
+# isgri
+
+Python package for ISGRI (INTEGRAL Soft Gamma-Ray Imager) lightcurve analysis.
+
+## Installation
+
+```bash
+pip install isgri
+```
+
+Or from source:
+```bash
+git clone https://github.com/yourusername/isgri.git
+cd isgri
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from isgri.utils import LightCurve, QualityMetrics
+
+# Load data
+lc = LightCurve.load_data(
+    events_path='/path/to/isgri_events.fits',
+    pif_path='/path/to/source_model.fits'
+)
+
+# Create lightcurve
+time, counts = lc.rebin(binsize=1.0, emin=30, emax=300)
+
+# Create lightcurve per each module
+times, module_counts = lc.rebin_by_modules(binsize=1.0, emin=30, emax=300)
+
+# Compute quality metrics
+qm = QualityMetrics(lc, binsize=1.0, emin=30, emax=300)
+chi = qm.raw_chi_squared()
+```
+
+## Features
+
+- Load ISGRI events and PIF files
+- Rebin lightcurves with custom binning
+- Module-by-module analysis (8 detector modules)
+- Quality metrics (chi-squared variability tests)
+- Time conversions (IJD ↔ UTC)
+- Custom event filtering
+
+## Documentation
+
+- **Tutorial**: See [demo/lightcurve_walkthrough.ipynb](demo/lightcurve_walkthrough.ipynb)
+- **API docs**: All functions have docstrings - use `help(LightCurve)`

isgri-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+isgri/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+isgri/utils/__init__.py,sha256=H83Al7urc6LNW5KUzUBRdtRBUTahiZmkehKFiK90RrU,183
+isgri/utils/file_loaders.py,sha256=c0k7B4Uk1OfNKC_TkHtRbHuEeAu4lHxcbCoYLPuRw5E,5503
+isgri/utils/lightcurve.py,sha256=qhD5NvHnaSWPWaUh0nWXObj93f-ii6TQu92FIL7aznk,10191
+isgri/utils/pif.py,sha256=oxndfoZp-y9FO_TXcCP3dmesvh-sC7hAy2u_1YwGitw,1317
+isgri/utils/quality.py,sha256=vNOkIFOkOTP1FAy_1-t5Xvi38gp6UNgXJN3T-DtM8es,7209
+isgri/utils/time_conversion.py,sha256=47aTXn6cvi-LjOptDY2W-rjeF_PjthZer61VIsJqsro,908
+isgri-0.1.0.dist-info/METADATA,sha256=6rocF7iR95JEZnw51lyDBIIiBd8dp5wMBa8Q7xfJ4kE,1487
+isgri-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+isgri-0.1.0.dist-info/licenses/LICENSE,sha256=Q8oxmHR1cSnEXSHCjY3qeXMtupZI_1ZQZ1MBt4oeANE,1102
+isgri-0.1.0.dist-info/RECORD,,

isgri-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

isgri-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dominik Patryk Pacholski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.