jaxspec 0.0.4__tar.gz → 0.0.6__tar.gz

{jaxspec-0.0.4 → jaxspec-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaxspec
-Version: 0.0.4
+Version: 0.0.6
 Summary: jaxspec is a bayesian spectral fitting library for X-ray astronomy.
 License: MIT
 Author: sdupourque
@@ -10,7 +10,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: arviz (>=0.17.1,<0.18.0)
+Requires-Dist: arviz (>=0.17.1,<0.19.0)
 Requires-Dist: astropy (>=6.0.0,<7.0.0)
 Requires-Dist: chainconsumer (>=1.0.0,<2.0.0)
 Requires-Dist: cmasher (>=1.6.3,<2.0.0)
@@ -20,11 +20,13 @@ Requires-Dist: jax (>=0.4.23,<0.5.0)
 Requires-Dist: jaxlib (>=0.4.23,<0.5.0)
 Requires-Dist: jaxopt (>=0.8.1,<0.9.0)
 Requires-Dist: matplotlib (>=3.8.0,<4.0.0)
+Requires-Dist: mendeleev (>=0.15.0,<0.16.0)
 Requires-Dist: mkdocstrings (>=0.24.0,<0.25.0)
 Requires-Dist: networkx (>=3.1,<4.0)
 Requires-Dist: numpy (>=1.26.1,<2.0.0)
 Requires-Dist: numpyro (>=0.13.2,<0.15.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
+Requires-Dist: pyzmq (<26)
 Requires-Dist: scipy (<1.13)
 Requires-Dist: seaborn (>=0.13.1,<0.14.0)
 Requires-Dist: simpleeval (>=0.9.13,<0.10.0)
@@ -50,7 +52,7 @@ Documentation : https://jaxspec.readthedocs.io/en/latest/
 
 ## Installation
 
-We recommend the users to start from a fresh Python 3.10 [conda environment](https://conda.io/projects/conda/en/latest/user-guide/install/index.html). 
+We recommend the users to start from a fresh Python 3.10 [conda environment](https://conda.io/projects/conda/en/latest/user-guide/install/index.html).
 
 ```
 conda create -n jaxspec python=3.10

{jaxspec-0.0.4 → jaxspec-0.0.6}/README.md

@@ -16,7 +16,7 @@ Documentation : https://jaxspec.readthedocs.io/en/latest/
 
 ## Installation
 
-We recommend the users to start from a fresh Python 3.10 [conda environment](https://conda.io/projects/conda/en/latest/user-guide/install/index.html). 
+We recommend the users to start from a fresh Python 3.10 [conda environment](https://conda.io/projects/conda/en/latest/user-guide/install/index.html).
 
 ```
 conda create -n jaxspec python=3.10

{jaxspec-0.0.4 → jaxspec-0.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jaxspec"
-version = "0.0.4"
+version = "0.0.6"
 description = "jaxspec is a bayesian spectral fitting library for X-ray astronomy."
 authors = ["sdupourque <sdupourque@irap.omp.eu>"]
 license = "MIT"
@@ -17,7 +17,7 @@ numpyro = ">=0.13.2,<0.15.0"
 dm-haiku = ">=0.0.11,<0.0.13"
 networkx = "^3.1"
 matplotlib = "^3.8.0"
-arviz = "^0.17.1"
+arviz = ">=0.17.1,<0.19.0"
 chainconsumer = "^1.0.0"
 simpleeval = "^0.9.13"
 cmasher = "^1.6.3"
@@ -28,6 +28,8 @@ seaborn = "^0.13.1"
 mkdocstrings = "^0.24.0"
 sparse = "^0.15.1"
 scipy = "<1.13"
+mendeleev = "^0.15.0"
+pyzmq = "<26"
 
 
 [tool.poetry.group.docs.dependencies]

{jaxspec-0.0.4 → jaxspec-0.0.6}/src/jaxspec/__init__.py

@@ -1,5 +1,5 @@
 """
-This is the root of jaxspec's module. TODO: clear this up.
+This is the root of jaxspec's module.
 """
 
 import importlib.metadata

{jaxspec-0.0.4 → jaxspec-0.0.6}/src/jaxspec/analysis/compare.py

@@ -1,9 +1,9 @@
 from typing import Dict
-from .results import ChainResult
+from .results import FitResult
 from chainconsumer import ChainConsumer
 
 
-def plot_corner_comparison(obs_dict: Dict[str, ChainResult], **kwargs):
+def plot_corner_comparison(obs_dict: Dict[str, FitResult], **kwargs):
     """
     Plot the correlation plot of parameters from different fitted observations. Observations are passed in as a
     dictionary. Each observation is named according to its key. It shall be used to compare the same model independently
@@ -16,6 +16,6 @@ def plot_corner_comparison(obs_dict: Dict[str, ChainResult], **kwargs):
     c = ChainConsumer()
 
     for name, obs in obs_dict.items():
-        c.add_chain(obs.chain(name))
+        c.add_chain(obs.to_chain(name))
 
     return c.plotter.plot(**kwargs)

{jaxspec-0.0.4 → jaxspec-0.0.6}/src/jaxspec/analysis/results.py

@@ -1,11 +1,12 @@
 import arviz as az
 import numpy as np
+import xarray as xr
 import matplotlib.pyplot as plt
 from ..data import ObsConfiguration
 from ..model.abc import SpectralModel
 from ..model.background import BackgroundModel
 from collections.abc import Mapping
-from typing import TypeVar, Tuple, Literal
+from typing import TypeVar, Tuple, Literal, Any
 from astropy.cosmology import Cosmology, Planck18
 import astropy.units as u
 from astropy.units import Unit
@@ -17,6 +18,10 @@ from scipy.integrate import trapezoid
 
 K = TypeVar("K")
 V = TypeVar("V")
+T = TypeVar("T")
+
+
+class HaikuDict(dict[str, dict[str, T]]): ...
 
 
 def _plot_binned_samples_with_error(
@@ -69,7 +74,7 @@ def _plot_binned_samples_with_error(
 
         percentiles = np.percentile(y_samples, percentile, axis=0)
 
-        # The legend cannot handle fill_between, so we pass a fill to get a fancy icone
+        # The legend cannot handle fill_between, so we pass a fill to get a fancy icon
         (envelope,) = ax.fill(np.nan, np.nan, alpha=0.3, facecolor=color)
 
         ax.fill_between(
@@ -111,24 +116,24 @@ def format_parameters(parameter_name):
         return rf"${parameter}$" + module
 
 
-class ChainResult:
-    # TODO : Add docstring
+class FitResult:
+    """
+    This class is the container for the result of a fit using any ModelFitter class.
+    """
+
     # TODO : Add type hints
-    # TODO : Add proper separation between params and samples, cf from haiku and numpyro
     def __init__(
         self,
         model: SpectralModel,
-        folding_model: ObsConfiguration,
+        obsconf: ObsConfiguration | dict[str, ObsConfiguration],
         inference_data: az.InferenceData,
-        samples,
         structure: Mapping[K, V],
         background_model: BackgroundModel = None,
     ):
         self.model = model
         self._structure = structure
         self.inference_data = inference_data
-        self.folding_model = folding_model
-        self.samples = samples
+        self.obsconfs = {"Observation": obsconf} if isinstance(obsconf, ObsConfiguration) else obsconf
         self.background_model = background_model
         self._structure = structure
 
@@ -139,6 +144,14 @@ class ChainResult:
             metadata["model"] = str(model)
             # TODO : Store metadata about observations used in the fitting process
 
+    @property
+    def converged(self) -> bool:
+        """
+        Convergence of the chain as computed by the $\hat{R}$ statistic.
+        """
+
+        return all(az.rhat(self.inference_data) < 1.01)
+
     def photon_flux(
         self,
         e_min: float,
@@ -164,7 +177,7 @@ class ChainResult:
         conversion_factor = (u.photon / u.cm**2 / u.s).to(unit)
 
         value = flux * conversion_factor
-
+        # TODO : fix this since sample doesn't exist anymore
         self.samples[rf"Photon flux ({e_min:.1f}-{e_max:.1f} keV)"] = value
 
         return value
@@ -195,6 +208,7 @@ class ChainResult:
 
         value = flux * conversion_factor
 
+        # TODO : fix this since sample doesn't exist anymore
         self.samples[rf"Energy flux ({e_min:.1f}-{e_max:.1f} keV)"] = value
 
         return value
@@ -207,7 +221,7 @@ class ChainResult:
         observer_frame: bool = True,
         cosmology: Cosmology = Planck18,
         unit: Unit = u.erg / u.s,
-    ):
+    ) -> ArrayLike:
         """
         Compute the luminosity of the source specifying its redshift. The luminosity is then added to
         the result parameters so covariance can be plotted.
@@ -228,11 +242,12 @@ class ChainResult:
 
         value = (flux * (4 * np.pi * cosmology.luminosity_distance(redshift) ** 2)).to(unit)
 
+        # TODO : fix this since sample doesn't exist anymore
         self.samples[rf"Luminosity ({e_min:.1f}-{e_max:.1f} keV)"] = value
 
         return value
 
-    def chain(self, name: str, parameters: Literal["model", "bkg"] = "model") -> Chain:
+    def to_chain(self, name: str, parameters: Literal["model", "bkg"] = "model") -> Chain:
         """
         Return a ChainConsumer Chain object from the posterior distribution of the parameters.
 
@@ -257,9 +272,31 @@ class ChainResult:
         return chain
 
     @property
-    def params(self):
+    def samples_haiku(self) -> HaikuDict[ArrayLike]:
         """
-        Haiku-like structure for the parameters
+        Haiku-like structure for the samples e.g.
+
+        ```
+        {
+            'powerlaw_1' :
+            {
+                'alpha': ...,
+                'amplitude': ...
+            },
+
+            'blackbody_1':
+            {
+                'kT': ...,
+                'norm': ...
+            },
+
+            'tbabs_1':
+            {
+                'nH': ...
+            }
+        }
+        ```
+
         """
 
         params = {}
@@ -271,7 +308,40 @@ class ChainResult:
 
         return params
 
-    def plot_ppc(self, percentile: Tuple[int, int] = (14, 86)) -> plt.Figure:
+    @property
+    def samples_flat(self) -> dict[str, ArrayLike]:
+        """
+        Flat structure for the samples e.g.
+
+        ```
+        {
+            'powerlaw_1_alpha': ...,
+            'powerlaw_1_amplitude': ...,
+            'blackbody_1_kT': ...,
+            'blackbody_1_norm': ...,
+            'tbabs_1_nH': ...,
+        }
+        ```
+        """
+        var_names = [f"{m}_{n}" for m, n, _ in traverse(self._structure)]
+        posterior = az.extract(self.inference_data, var_names=var_names)
+        return {key: posterior[key].data for key in var_names}
+
+    @property
+    def likelihood(self) -> xr.Dataset:
+        """
+        Return the likelihood of each observation
+        """
+        log_likelihood = az.extract(self.inference_data, group="log_likelihood")
+        dimensions_to_reduce = [coord for coord in log_likelihood.coords if coord not in ["sample", "draw", "chain"]]
+        return log_likelihood.sum(dimensions_to_reduce)
+
+    def plot_ppc(
+        self,
+        percentile: Tuple[int, int] = (14, 86),
+        x_unit: str | u.Unit = "keV",
+        y_type: Literal["counts", "countrate", "photon_flux", "photon_flux_density"] = "photon_flux_density",
+    ) -> plt.Figure:
         r"""
         Plot the posterior predictive distribution of the model. It also features a residual plot, defined using the
         following formula:
@@ -281,115 +351,176 @@ class ChainResult:
 
         Parameters:
             percentile: The percentile of the posterior predictive distribution to plot.
+            x_unit: The units of the x-axis. It can be either a string (parsable by astropy.units) or an astropy unit. It must be homogeneous to either a length, a frequency or an energy.
+            y_type: The type of the y-axis. It can be either "counts", "countrate", "photon_flux" or "photon_flux_density".
 
         Returns:
-            The matplotlib two panel figure.
+            The matplotlib figure.
         """
 
-        folding_model = self.folding_model
-        count = az.extract(self.inference_data, var_names="obs", group="posterior_predictive").values.T
-        bkg_count = (
-            None
-            if self.background_model is None
-            else az.extract(self.inference_data, var_names="bkg", group="posterior_predictive").values.T
-        )
-
-        legend_plots = []
-        legend_labels = []
+        obsconf_container = self.obsconfs
+        x_unit = u.Unit(x_unit)
+
+        match y_type:
+            case "counts":
+                y_units = u.photon
+            case "countrate":
+                y_units = u.photon / u.s
+            case "photon_flux":
+                y_units = u.photon / u.cm**2 / u.s
+            case "photon_flux_density":
+                y_units = u.photon / u.cm**2 / u.s / x_unit
+            case _:
+                raise ValueError(
+                    f"Unknown y_type: {y_type}. Must be 'counts', 'countrate', 'photon_flux' or 'photon_flux_density'"
+                )
 
         color = (0.15, 0.25, 0.45)
 
         with plt.style.context("default"):
-            # Note to Simon : do not change folding_model.out_energies[1] - folding_model.out_energies[0] to
+            # Note to Simon : do not change xbins[1] - xbins[0] to
             # np.diff, you already did this twice and forgot that it does not work since diff keeps the dimensions
             # and enable weird broadcasting that makes the plot fail
 
-            fig, axs = plt.subplots(2, 1, figsize=(6, 6), sharex=True, height_ratios=[0.7, 0.3])
-
-            mid_bins_arf = folding_model.in_energies.mean(axis=0)
-
-            e_grid = np.linspace(*folding_model.out_energies, 10)
-            interpolated_arf = np.interp(e_grid, mid_bins_arf, folding_model.area)
-            integrated_arf = trapezoid(interpolated_arf, x=e_grid, axis=0) / (
-                folding_model.out_energies[1] - folding_model.out_energies[0]
-            )
-
-            if folding_model.out_energies[0][0] < 1 < folding_model.out_energies[1][-1]:
-                xticks = [np.floor(folding_model.out_energies[0][0] * 10) / 10, 1.0, np.floor(folding_model.out_energies[1][-1])]
-            else:
-                xticks = [np.floor(folding_model.out_energies[0][0] * 10) / 10, np.floor(folding_model.out_energies[1][-1])]
-
-            denominator = (
-                (folding_model.out_energies[1] - folding_model.out_energies[0]) * folding_model.exposure.data * integrated_arf
+            fig, axs = plt.subplots(
+                2, len(obsconf_container), figsize=(6 * len(obsconf_container), 6), sharex=True, height_ratios=[0.7, 0.3]
             )
 
-            # Use the helper function to plot the data and posterior predictive
-            legend_plots += _plot_binned_samples_with_error(
-                axs[0],
-                folding_model.out_energies,
-                y_samples=count,
-                y_observed=folding_model.folded_counts.data,
-                denominator=denominator,
-                color=color,
-                percentile=percentile,
-            )
+            plot_ylabels_once = True
+
+            for name, obsconf, ax in zip(
+                obsconf_container.keys(), obsconf_container.values(), axs.T if len(obsconf_container) > 1 else [axs]
+            ):
+                legend_plots = []
+                legend_labels = []
+                count = az.extract(self.inference_data, var_names=f"obs_{name}", group="posterior_predictive").values.T
+                bkg_count = (
+                    None
+                    if self.background_model is None
+                    else az.extract(self.inference_data, var_names=f"bkg_{name}", group="posterior_predictive").values.T
+                )
 
-            legend_labels.append("Source + Background")
+                xbins = obsconf.out_energies * u.keV
+                xbins = xbins.to(x_unit, u.spectral())
+
+                # This compute the total effective area within all bins
+                # This is a bit weird since the following computation is equivalent to ignoring the RMF
+                exposure = obsconf.exposure.data * u.s
+                mid_bins_arf = obsconf.in_energies.mean(axis=0) * u.keV
+                mid_bins_arf = mid_bins_arf.to(x_unit, u.spectral())
+                e_grid = np.linspace(*xbins, 10)
+                interpolated_arf = np.interp(e_grid, mid_bins_arf, obsconf.area)
+                integrated_arf = (
+                    trapezoid(interpolated_arf, x=e_grid, axis=0)
+                    / (
+                        np.abs(xbins[1] - xbins[0])  # Must fold in abs because some units reverse the ordering of the bins
+                    )
+                    * u.cm**2
+                )
 
-            if self.background_model is not None:
-                # We plot the background only if it is included in the fit, i.e. by subtracting
+                """
+                if xbins[0][0] < 1 < xbins[1][-1]:
+                    xticks = [np.floor(xbins[0][0] * 10) / 10, 1.0, np.floor(xbins[1][-1])]
+                else:
+                    xticks = [np.floor(xbins[0][0] * 10) / 10, np.floor(xbins[1][-1])]
+                """
+
+                match y_type:
+                    case "counts":
+                        denominator = 1
+                    case "countrate":
+                        denominator = exposure
+                    case "photon_flux":
+                        denominator = integrated_arf * exposure
+                    case "photon_flux_density":
+                        denominator = (xbins[1] - xbins[0]) * integrated_arf * exposure
+
+                y_samples = (count * u.photon / denominator).to(y_units)
+                y_observed = (obsconf.folded_counts.data * u.photon / denominator).to(y_units)
+
+                # Use the helper function to plot the data and posterior predictive
                 legend_plots += _plot_binned_samples_with_error(
-                    axs[0],
-                    folding_model.out_energies,
-                    y_observed=folding_model.folded_background.data,
-                    y_samples=bkg_count,
-                    denominator=denominator * folding_model.folded_backratio.data,
-                    color=(0.26787604, 0.60085972, 0.63302651),
+                    ax[0],
+                    xbins.value,
+                    y_samples=y_samples.value,
+                    y_observed=y_observed.value,
+                    denominator=np.ones_like(y_observed).value,
+                    color=color,
                     percentile=percentile,
                 )
 
-                legend_labels.append("Background")
-
-            residuals = np.percentile(
-                (folding_model.folded_counts.data - count) / np.diff(np.percentile(count, percentile, axis=0), axis=0),
-                percentile,
-                axis=0,
-            )
-
-            axs[1].fill_between(
-                list(folding_model.out_energies[0]) + [folding_model.out_energies[1][-1]],
-                list(residuals[0]) + [residuals[0][-1]],
-                list(residuals[1]) + [residuals[1][-1]],
-                alpha=0.3,
-                step="post",
-                facecolor=color,
-            )
-
-            max_residuals = np.max(np.abs(residuals))
-
-            axs[0].loglog()
-            axs[0].set_ylabel("Folded spectrum\n" + r"[Counts s$^{-1}$ keV$^{-1}$ cm$^{-2}$]")
-
-            axs[1].set_ylim(-max(3.5, max_residuals), +max(3.5, max_residuals))
-            axs[1].set_ylabel("Residuals \n" + r"[$\sigma$]")
-            axs[1].set_xlabel("Energy \n[keV]")
-
-            axs[1].axhline(0, color=color, ls="--")
-            axs[1].axhline(-3, color=color, ls=":")
-            axs[1].axhline(3, color=color, ls=":")
-
-            axs[1].set_xticks(xticks, labels=xticks)
-            axs[1].set_yticks([-3, 0, 3], labels=[-3, 0, 3])
-            axs[1].set_yticks(range(-3, 4), minor=True)
-
-            axs[0].set_xlim(folding_model.out_energies.min(), folding_model.out_energies.max())
+                legend_labels.append("Source + Background")
+
+                if self.background_model is not None:
+                    # We plot the background only if it is included in the fit, i.e. by subtracting
+                    ratio = obsconf.folded_backratio.data
+                    y_samples_bkg = (bkg_count * u.photon / (denominator * ratio)).to(y_units)
+                    y_observed_bkg = (obsconf.folded_background.data * u.photon / (denominator * ratio)).to(y_units)
+                    legend_plots += _plot_binned_samples_with_error(
+                        ax[0],
+                        xbins.value,
+                        y_samples=y_samples_bkg.value,
+                        y_observed=y_observed_bkg.value,
+                        denominator=np.ones_like(y_observed).value,
+                        color=(0.26787604, 0.60085972, 0.63302651),
+                        percentile=percentile,
+                    )
+
+                    legend_labels.append("Background")
+
+                residuals = np.percentile(
+                    (obsconf.folded_counts.data - count) / np.diff(np.percentile(count, percentile, axis=0), axis=0),
+                    percentile,
+                    axis=0,
+                )
 
-            axs[0].legend(legend_plots, legend_labels)
-            fig.suptitle(self.model.to_string())
+                ax[1].fill_between(
+                    list(xbins.value[0]) + [xbins.value[1][-1]],
+                    list(residuals[0]) + [residuals[0][-1]],
+                    list(residuals[1]) + [residuals[1][-1]],
+                    alpha=0.3,
+                    step="post",
+                    facecolor=color,
+                )
 
-            fig.align_ylabels()
-            plt.subplots_adjust(hspace=0.0)
-            fig.tight_layout()
+                max_residuals = np.max(np.abs(residuals))
+
+                ax[0].loglog()
+                ax[1].set_ylim(-max(3.5, max_residuals), +max(3.5, max_residuals))
+
+                if plot_ylabels_once:
+                    ax[0].set_ylabel(f"Folded spectrum\n [{y_units:latex_inline}]")
+                    ax[1].set_ylabel("Residuals \n" + r"[$\sigma$]")
+                    plot_ylabels_once = False
+
+                match getattr(x_unit, "physical_type"):
+                    case "length":
+                        ax[1].set_xlabel(f"Wavelength \n[{x_unit:latex_inline}]")
+                    case "energy":
+                        ax[1].set_xlabel(f"Energy \n[{x_unit:latex_inline}]")
+                    case "frequency":
+                        ax[1].set_xlabel(f"Frequency \n[{x_unit:latex_inline}]")
+                    case _:
+                        RuntimeError(
+                            f"Unknown physical type for x_units: {x_unit}. " f"Must be 'length', 'energy' or 'frequency'"
+                        )
+
+                ax[1].axhline(0, color=color, ls="--")
+                ax[1].axhline(-3, color=color, ls=":")
+                ax[1].axhline(3, color=color, ls=":")
+
+                # ax[1].set_xticks(xticks, labels=xticks)
+                # ax[1].xaxis.set_minor_formatter(ticker.LogFormatter(minor_thresholds=(np.inf, np.inf)))
+                ax[1].set_yticks([-3, 0, 3], labels=[-3, 0, 3])
+                ax[1].set_yticks(range(-3, 4), minor=True)
+
+                ax[0].set_xlim(xbins.value.min(), xbins.value.max())
+
+                ax[0].legend(legend_plots, legend_labels)
+                fig.suptitle(self.model.to_string())
+                fig.align_ylabels()
+                plt.subplots_adjust(hspace=0.0)
+                fig.tight_layout()
 
             return fig
 
@@ -399,29 +530,27 @@ class ChainResult:
         """
 
         consumer = ChainConsumer()
-        consumer.add_chain(self.chain(self.model.to_string()))
+        consumer.add_chain(self.to_chain(self.model.to_string()))
 
         return consumer.analysis.get_latex_table(caption="Results of the fit", label="tab:results")
 
     def plot_corner(
         self,
         config: PlotConfig = PlotConfig(usetex=False, summarise=False, label_font_size=6),
-        style="default",
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> plt.Figure:
         """
         Plot the corner plot of the posterior distribution of the parameters. This method uses the ChainConsumer.
 
         Parameters:
             config: The configuration of the plot.
-            style: The matplotlib style of the plot.
             **kwargs: Additional arguments passed to ChainConsumer.plotter.plot.
         """
 
         consumer = ChainConsumer()
-        consumer.add_chain(self.chain(self.model.to_string()))
+        consumer.add_chain(self.to_chain(self.model.to_string()))
         consumer.set_plot_config(config)
 
         # Context for default mpl style
-        with plt.style.context(style):
+        with plt.style.context("default"):
             return consumer.plotter.plot(**kwargs)

{jaxspec-0.0.4 → jaxspec-0.0.6}/src/jaxspec/data/instrument.py

@@ -72,8 +72,6 @@ class Instrument(xr.Dataset):
         Parameters:
             rmf_path: The RMF file path.
             arf_path: The ARF file path.
-            exposure: The exposure time in second.
-            grouping: The grouping matrix.
         """
 
         rmf = DataRMF.from_file(rmf_path)

{jaxspec-0.0.4 → jaxspec-0.0.6}/src/jaxspec/data/ogip.py

@@ -75,6 +75,24 @@ class DataPHA:
         data = QTable.read(pha_file, "SPECTRUM")
         header = fits.getheader(pha_file, "SPECTRUM")
 
+        if header.get("HDUCLAS2") == "NET":
+            raise ValueError(
+                f"The HDUCLAS2={header.get('HDUCLAS2')} keyword in the PHA file is not supported."
+                f"Please open an issue if this is required."
+            )
+
+        if header.get("HDUCLAS3") == "RATE":
+            raise ValueError(
+                f"The HDUCLAS3={header.get('HDUCLAS3')} keyword in the PHA file is not supported."
+                f"Please open an issue if this is required."
+            )
+
+        if header.get("HDUCLAS4") == "TYPE:II":
+            raise ValueError(
+                f"The HDUCLAS4={header.get('HDUCLAS4')} keyword in the PHA file is not supported."
+                f"Please open an issue if this is required."
+            )
+
         if header.get("GROUPING") == 0:
             grouping = None
         elif "GROUPING" in data.colnames: