gammapy__gammapy-5674

{
  "status": "ok",
  "stdout": "gammapy/estimators/points/core.py:840:    def resample_axis(self, axis_new):\ngammapy/estimators/points/tests/test_core.py:419:def test_resample_axis():\ngammapy/estimators/points/tests/test_core.py:427:    l1 = lc_1d.resample_axis(axis_new=axis_new)\ngammapy/estimators/points/tests/test_core.py:436:    l1 = lc_1d.resample_axis(axis_new=axis_new)\ngammapy/estimators/points/tests/test_core.py:447:        fp.resample_axis(axis_new=MapAxis.from_nodes([0, 1, 2]))\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "\ndef squash_fluxpoints(flux_point, axis):\n    \"\"\"Squash a `~FluxPoints` object into one point.\n\n    The log-likelihoods profiles in each bin are summed\n    to compute the resultant quantities. Stat profiles\n    must be present on the `~FluxPoints` object for\n    this method to work.\n    \"\"\"\n    value_scan = flux_point.stat_scan.geom.axes[\"norm\"].center\n    stat_scan = np.sum(flux_point.stat_scan.data, axis=0).ravel()\n    f = interp1d(value_scan, stat_scan, kind=\"quadratic\", bounds_error=False)\n    f = interpolate_profile(value_scan, stat_scan)\n    minimizer = minimize(\n        f,\n        x0=value_scan[int(len(value_scan) / 2)],\n        bounds=[(value_scan[0], value_scan[-1])],\n        method=\"L-BFGS-B\",\n    )\n\n    maps = Maps()\n    geom = flux_point.geom.to_image()\n    if axis.name != \"energy\":\n        geom = geom.to_cube([flux_point.geom.axes[\"energy\"]])\n\n    maps[\"norm\"] = Map.from_geom(geom, data=minimizer.x)\n    maps[\"norm_err\"] = Map.from_geom(\n        geom, data=np.sqrt(minimizer.hess_inv.todense()).reshape(geom.data_shape)\n    )\n    maps[\"n_dof\"] = Map.from_geom(geom, data=flux_point.geom.axes[axis.name].nbin)\n\n    if \"norm_ul\" in flux_point.available_quantities:\n        delta_ts = flux_point.meta.get(\"n_sigma_ul\", 2) ** 2\n        ul = stat_profile_ul_scipy(value_scan, stat_scan, delta_ts=delta_ts)\n        maps[\"norm_ul\"] = Map.from_geom(geom, data=ul.value)\n\n    maps[\"stat\"] = Map.from_geom(geom, data=f(minimizer.x))\n\n    geom_scan = geom.to_cube([MapAxis.from_nodes(value_scan, name=\"norm\")])\n    maps[\"stat_scan\"] = Map.from_geom(\n        geom=geom_scan, data=stat_scan.reshape(geom_scan.data_shape)\n    )\n    try:\n        maps[\"stat_null\"] = Map.from_geom(geom, data=np.sum(flux_point.stat_null.data))\n        maps[\"ts\"] = maps[\"stat_null\"] - maps[\"stat\"]\n    except AttributeError:\n        log.info(\n            \"Stat null info not present on original FluxPoints object. TS not computed\"\n        )\n\n    maps[\"success\"] = Map.from_geom(geom=geom, data=minimizer.success, dtype=bool)\n\n    combined_fp = FluxPoints.from_maps(\n        maps=maps,\n        sed_type=flux_point.sed_type_init,\n        reference_model=flux_point.reference_model,\n        gti=flux_point.gti,\n        meta=flux_point.meta,\n    )\n    return combined_fp\n\n\nclass FluxPoints(FluxMaps):\n    \"\"\"Flux points container.\n\n    The supported formats are described here: :ref:`gadf:flux-points`.\n\n    In summary, the following formats and minimum required columns are:\n\n    * Format ``dnde``: columns ``e_ref`` and ``dnde``\n    * Format ``e2dnde``: columns ``e_ref``, ``e2dnde``\n    * Format ``flux``: columns ``e_min``, ``e_max``, ``flux``\n    * Format ``eflux``: columns ``e_min``, ``e_max``, ``eflux``\n\n    Parameters\n    ----------\n    table : `~astropy.table.Table`\n        Table with flux point data.\n\n    Attributes\n    ----------\n    table : `~astropy.table.Table`\n        Table with flux point data.\n\n    Examples\n    --------\n    The `FluxPoints` object is most easily created by reading a file with\n    flux points given in one of the formats documented above::\n\n    >>> from gammapy.estimators import FluxPoints\n    >>> filename = '$GAMMAPY_DATA/hawc_crab/HAWC19_flux_points.fits'\n    >>> flux_points = FluxPoints.read(filename)\n    >>> flux_points.plot() #doctest: +SKIP\n\n    An instance of `FluxPoints` can also be created by passing an instance of\n    `astropy.table.Table`, which contains the required columns, such as `'e_ref'`\n    and `'dnde'`. The corresponding `sed_type` has to be defined in the meta data\n    of the table::\n\n    >>> import numpy as np\n    >>> from astropy import units as u\n    >>> from astropy.table import Table\n    >>> from gammapy.estimators import FluxPoints\n    >>> from gammapy.modeling.models import PowerLawSpectralModel\n    >>> table = Table()\n    >>> pwl = PowerLawSpectralModel()\n    >>> e_ref = np.geomspace(1, 100, 7) * u.TeV\n    >>> table[\"e_ref\"] = e_ref\n    >>> table[\"dnde\"] = pwl(e_ref)\n    >>> table[\"dnde_err\"] = pwl.evaluate_error(e_ref)[0]\n    >>> table.meta[\"SED_TYPE\"] = \"dnde\"\n    >>> flux_points = FluxPoints.from_table(table)\n    >>> flux_points.plot(sed_type=\"flux\") #doctest: +SKIP\n\n    If you have flux points in a different data format, the format can be changed\n    by renaming the table columns and adding meta data::\n\n\n    >>> from astropy import units as u\n    >>> from astropy.table import Table\n    >>> from gammapy.estimators import FluxPoints\n    >>> from gammapy.utils.scripts import make_path\n\n    >>> filename = make_path('$GAMMAPY_DATA/tests/spectrum/flux_points/flux_points_ctb_37b.txt')\n    >>> table = Table.read(filename ,format='ascii.csv', delimiter=' ', comment='#')\n    >>> table.rename_column('Differential_Flux', 'dnde')\n    >>> table['dnde'].unit = 'cm-2 s-1 TeV-1'\n\n    >>> table.rename_column('lower_error', 'dnde_errn')\n    >>> table['dnde_errn'].unit = 'cm-2 s-1 TeV-1'\n\n    >>> table.rename_column('upper_error', 'dnde_errp')\n    >>> table['dnde_errp'].unit = 'cm-2 s-1 TeV-1'\n\n    >>> table.rename_column('E', 'e_ref')\n    >>> table['e_ref'].unit = 'TeV'\n\n    >>> flux_points = FluxPoints.from_table(table, sed_type=\"dnde\")\n    >>> flux_points.plot(sed_type=\"e2dnde\") #doctest: +SKIP\n\n\n    Note: In order to reproduce the example you need the tests datasets folder.\n    You may download it with the command\n    ``gammapy download datasets --tests --out $GAMMAPY_DATA``\n    \"\"\"\n\n    @classmethod\n    def read(\n        cls,\n        filename,",
  "start_line": 30,
  "end_line": 179,
  "total_lines": 872,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\nimport logging\nfrom copy import deepcopy\nimport numpy as np\nfrom scipy import stats\nfrom scipy.interpolate import interp1d\nfrom scipy.optimize import minimize\nfrom astropy.io import fits\nfrom astropy.io.registry import IORegistryError\nfrom astropy.table import Table, vstack\nfrom astropy.time import Time\nfrom astropy.visualization import quantity_support\nimport matplotlib.pyplot as plt\nfrom gammapy.data import GTI\nfrom gammapy.maps import Map, MapAxis, Maps, RegionNDMap, TimeMapAxis\nfrom gammapy.maps.axes import UNIT_STRING_FORMAT, flat_if_equal\nfrom gammapy.modeling.models import TemplateSpectralModel\nfrom gammapy.modeling.models.spectral import scale_plot_flux\nfrom gammapy.modeling.scipy import stat_profile_ul_scipy\nfrom gammapy.utils.interpolation import interpolate_profile\nfrom gammapy.utils.scripts import make_path\nfrom gammapy.utils.table import table_standardise_units_copy\nfrom gammapy.utils.time import time_ref_to_dict\nfrom ..map.core import DEFAULT_UNIT, FluxMaps\n\n__all__ = [\"FluxPoints\"]\n\nlog = logging.getLogger(__name__)\n\n\ndef squash_fluxpoints(flux_point, axis):\n    \"\"\"Squash a `~FluxPoints` object into one point.\n\n    The log-likelihoods profiles in each bin are summed\n    to compute the resultant quantities. Stat profiles\n    must be present on the `~FluxPoints` object for\n    this method to work.\n    \"\"\"\n    value_scan = flux_point.stat_scan.geom.axes[\"norm\"].center\n    stat_scan = np.sum(flux_point.stat_scan.data, axis=0).ravel()\n    f = interp1d(value_scan, stat_scan, kind=\"quadratic\", bounds_error=False)\n    f = interpolate_profile(value_scan, stat_scan)\n    minimizer = minimize(\n        f,\n        x0=value_scan[int(len(value_scan) / 2)],\n        bounds=[(value_scan[0], value_scan[-1])],\n        method=\"L-BFGS-B\",\n    )\n\n    maps = Maps()\n    geom = flux_point.geom.to_image()\n    if axis.name != \"energy\":\n        geom = geom.to_cube([flux_point.geom.axes[\"energy\"]])\n\n    maps[\"norm\"] = Map.from_geom(geom, data=minimizer.x)\n    maps[\"norm_err\"] = Map.from_geom(\n        geom, data=np.sqrt(minimizer.hess_inv.todense()).reshape(geom.data_shape)\n    )\n    maps[\"n_dof\"] = Map.from_geom(geom, data=flux_point.geom.axes[axis.name].nbin)\n\n    if \"norm_ul\" in flux_point.available_quantities:\n        delta_ts = flux_point.meta.get(\"n_sigma_ul\", 2) ** 2\n        ul = stat_profile_ul_scipy(value_scan, stat_scan, delta_ts=delta_ts)\n        maps[\"norm_ul\"] = Map.from_geom(geom, data=ul.value)\n\n    maps[\"stat\"] = Map.from_geom(geom, data=f(minimizer.x))\n\n    geom_scan = geom.to_cube([MapAxis.from_nodes(value_scan, name=\"norm\")])\n    maps[\"stat_scan\"] = Map.from_geom(\n        geom=geom_scan, data=stat_scan.reshape(geom_scan.data_shape)\n    )\n    try:\n        maps[\"stat_null\"] = Map.from_geom(geom, data=np.sum(flux_point.stat_null.data))\n        maps[\"ts\"] = maps[\"stat_null\"] - maps[\"stat\"]\n    except AttributeError:\n        log.info(\n            \"Stat null info not present on original FluxPoints object. TS not computed\"\n        )\n\n    maps[\"success\"] = Map.from_geom(geom=geom, data=minimizer.success, dtype=bool)\n\n    combined_fp = FluxPoints.from_maps(\n        maps=maps,\n        sed_type=flux_point.sed_type_init,\n        reference_model=flux_point.reference_model,\n        gti=flux_point.gti,\n        meta=flux_point.meta,\n    )\n    return combined_fp\n\n\nclass FluxPoints(FluxMaps):\n    \"\"\"Flux points container.\n\n    The supported formats are described here: :ref:`gadf:flux-points`.\n\n    In summary, the following formats and minimum required columns are:\n\n    * Format ``dnde``: columns ``e_ref`` and ``dnde``\n    * Format ``e2dnde``: columns ``e_ref``, ``e2dnde``\n    * Format ``flux``: columns ``e_min``, ``e_max``, ``flux``\n    * Format ``eflux``: columns ``e_min``, ``e_max``, ``eflux``\n\n    Parameters\n    ----------\n    table : `~astropy.table.Table`\n        Table with flux point data.\n\n    Attributes\n    ----------\n    table : `~astropy.table.Table`\n        Table with flux point data.\n\n    Examples\n    --------\n    The `FluxPoints` object is most easily created by reading a file with\n    flux points given in one of the formats documented above::\n\n    >>> from gammapy.estimators import FluxPoints\n    >>> filename = '$GAMMAPY_DATA/hawc_crab/HAWC19_flux_points.fits'\n    >>> flux_points = FluxPoints.read(filename)\n    >>> flux_points.plot() #doctest: +SKIP\n\n    An instance of `FluxPoints` can also be created by passing an instance of\n    `astropy.table.Table`, which contains the required columns, such as `'e_ref'`\n    and `'dnde'`. The corresponding `sed_type` has to be defined in the meta data\n    of the table::\n\n    >>> import numpy as np\n    >>> from astropy import units as u\n    >>> from astropy.table import Table\n    >>> from gammapy.estimators import FluxPoints\n    >>> from gammapy.modeling.models import PowerLawSpectralModel\n    >>> table = Table()\n    >>> pwl = PowerLawSpectralModel()\n    >>> e_ref = np.geomspace(1, 100, 7) * u.TeV\n    >>> table[\"e_ref\"] = e_ref\n    >>> table[\"dnde\"] = pwl(e_ref)\n    >>> table[\"dnde_err\"] = pwl.evaluate_error(e_ref)[0]\n    >>> table.meta[\"SED_TYPE\"] = \"dnde\"\n    >>> flux_points = FluxPoints.from_table(table)\n    >>> flux_points.plot(sed_type=\"flux\") #doctest: +SKIP\n\n    If you have flux points in a different data format, the format can be changed\n    by renaming the table columns and adding meta data::\n\n\n    >>> from astropy import units as u\n    >>> from astropy.table import Table\n    >>> from gammapy.estimators import FluxPoints",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 872,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "    def resample_axis(self, axis_new):\n        \"\"\"Rebin the flux point object along the new axis.\n\n        The log-likelihoods profiles in each bin are summed\n        to compute the resultant quantities.\n        Stat profiles must be present on the `~gammapy.estimators.FluxPoints` object for\n        this method to work.\n\n        For now, works only for flat `~gammapy.estimators.FluxPoints`.\n\n        Parameters\n        ----------\n        axis_new : `MapAxis` or `TimeMapAxis`\n            The new axis to resample along\n\n        Returns\n        -------\n        flux_points : `~gammapy.estimators.FluxPoints`\n            A new FluxPoints object with modified axis.\n        \"\"\"\n        if not self.has_stat_profiles:\n            raise ValueError(\"Stat profiles not present, rebinning is not possible\")\n\n        fluxpoints = []\n        for edge_min, edge_max in zip(axis_new.edges_min, axis_new.edges_max):\n            if isinstance(axis_new, TimeMapAxis):\n                edge_min = edge_min + axis_new.reference_time\n                edge_max = edge_max + axis_new.reference_time\n            fp = self.slice_by_coord({axis_new.name: slice(edge_min, edge_max)})\n            fp_new = squash_fluxpoints(fp, axis_new)\n            fluxpoints.append(fp_new)\n\n        return self.__class__.from_stack(fluxpoints, axis=axis_new)",
  "start_line": 840,
  "end_line": 872,
  "total_lines": 872,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "gammapy/maps/region/ndmap.py",
  "content": "    meta : `dict`, optional\n        Dictionary to store metadata.\n        Default is None.\n    unit : str or `~astropy.units.Unit`, optional\n        The map unit.\n        Default is \"\".\n    \"\"\"\n\n    def __init__(self, geom, data=None, dtype=\"float32\", meta=None, unit=\"\"):\n        if data is None:\n            data = np.zeros(geom.data_shape, dtype=dtype)\n\n        if meta is None:\n            meta = {}\n\n        self._geom = geom\n        self.data = data\n        self.meta = meta\n        self._unit = u.Unit(unit)\n\n    @property\n    def data(self):\n        return self._data\n\n    @data.setter\n    def data(self, value):\n        \"\"\"Set data.\n        Parameters\n        ----------\n        value : array-like\n            Data array.\n        \"\"\"\n        if np.isscalar(value):\n            value = value * np.ones(self.geom.data_shape, dtype=type(value))\n\n        if isinstance(value, u.Quantity):\n            raise TypeError(\"Map data must be a Numpy array. Set unit separately\")\n\n        input_shape = value.shape\n        if len(self.geom.data_shape) == 2 + len(value.shape):\n            if self.geom.data_shape[: len(value.shape)] == value.shape:\n                value = np.expand_dims(value, (-2, -1))\n\n        if self.geom.data_shape != value.shape:\n            raise ValueError(\n                f\"Input shape {input_shape} is not compatible with shape from geometry {self.geom.data_shape}\"\n            )\n\n        self._data = value\n\n    def plot(self, ax=None, axis_name=None, **kwargs):\n        \"\"\"Plot the data contained in region map along the non-spatial axis.\n\n        Parameters\n        ----------\n        ax : `~matplotlib.pyplot.Axis`, optional\n            Axis used for plotting.\n            Default is None.\n        axis_name : str, optional\n            Which axis to plot on the x-axis. Extra axes will be plotted as\n            additional lines. Default is None.",
  "start_line": 40,
  "end_line": 100,
  "total_lines": 837,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "39:    value_scan = flux_point.stat_scan.geom.axes[\"norm\"].center\n40:    stat_scan = np.sum(flux_point.stat_scan.data, axis=0).ravel()\n41:    f = interp1d(value_scan, stat_scan, kind=\"quadratic\", bounds_error=False)\n42:    f = interpolate_profile(value_scan, stat_scan)\n63:        ul = stat_profile_ul_scipy(value_scan, stat_scan, delta_ts=delta_ts)\n69:    maps[\"stat_scan\"] = Map.from_geom(\n70:        geom=geom_scan, data=stat_scan.reshape(geom_scan.data_shape)\n300:        if \"dloglike_scan\" in table.colnames and \"stat_scan\" not in table.colnames:\n301:            table[\"stat_scan\"] = 2 * table[\"dloglike_scan\"]\n499:                norm_axis = self.stat_scan.geom.axes[\"norm\"]\n502:                table[\"stat_scan\"] = self.stat_scan.data[idx]\n828:        value_scan = self.stat_scan.geom.axes[\"norm\"].center\n829:        shape_axes = self.stat_scan.geom._shape[slice(3, None)][::-1]\n831:            stat_scan = np.abs(\n832:                self.stat_scan.data[idx].squeeze() - self.stat.data[idx].squeeze()\n835:                value_scan, stat_scan, delta_ts=delta_ts, **kwargs\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "317:    def from_table(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "    def from_table(\n        cls, table, sed_type=None, format=None, reference_model=None, gti=None\n    ):\n        \"\"\"Create flux points from a table. The table column names must be consistent with the sed_type.\n\n        Parameters\n        ----------\n        table : `~astropy.table.Table`\n            Table.\n        sed_type : {\"dnde\", \"flux\", \"eflux\", \"e2dnde\", \"likelihood\"}, optional\n            SED type. Default is None.\n        format : {\"gadf-sed\", \"lightcurve\", \"profile\"}, optional\n            Table format. If None, it is extracted from the table column content. Default is None.\n        reference_model : `SpectralModel`, optional\n            Reference spectral model. Default is None.\n        gti : `GTI`, optional\n            Good time intervals. Default is None.\n\n        Returns\n        -------\n        flux_points : `FluxPoints`\n            Flux points.\n        \"\"\"\n        table = table_standardise_units_copy(table)\n\n        if format is None:\n            format = cls._table_guess_format(table)\n            log.info(\"Inferred format: \" + format)\n\n        if sed_type is None:\n            sed_type = table.meta.get(\"SED_TYPE\", None)\n\n        if sed_type is None:\n            sed_type = cls._guess_sed_type(table.colnames)\n\n        if sed_type is None:\n            raise ValueError(\"Specifying the SED type is required\")\n\n        if sed_type == \"likelihood\":\n            table = cls._convert_loglike_columns(table)\n            if reference_model is None:\n                reference_model = TemplateSpectralModel(\n                    energy=flat_if_equal(table[\"e_ref\"].quantity),\n                    values=flat_if_equal(table[\"ref_dnde\"].quantity),",
  "start_line": 317,
  "end_line": 360,
  "total_lines": 872,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "                )\n\n        maps = Maps()\n        table.meta.setdefault(\"SED_TYPE\", sed_type)\n\n        for name in cls.all_quantities(sed_type=sed_type):\n            if name in table.colnames:\n                maps[name] = RegionNDMap.from_table(\n                    table=table, colname=name, format=format\n                )\n\n        meta = cls._get_meta_gadf(table)\n        return cls.from_maps(\n            maps=maps,\n            reference_model=reference_model,\n            meta=meta,\n            sed_type=sed_type,\n            gti=gti,\n        )\n\n    @staticmethod\n    def _get_meta_gadf(table):\n        meta = {}\n        meta.update(table.meta)\n        conf_ul = table.meta.get(\"UL_CONF\")\n        if conf_ul:\n            n_sigma_ul = np.round(stats.norm.isf(0.5 * (1 - conf_ul)), 1)\n            meta[\"n_sigma_ul\"] = n_sigma_ul\n        meta[\"sed_type_init\"] = table.meta.get(\"SED_TYPE\")\n        return meta\n\n    @staticmethod\n    def _format_table(table):\n        \"\"\"Format table.\"\"\"\n        for column in table.colnames:\n            if column.startswith((\"dnde\", \"eflux\", \"flux\", \"e2dnde\", \"ref\")):\n                table[column].format = \".3e\"\n            elif column.startswith(\n                (\"e_min\", \"e_max\", \"e_ref\", \"sqrt_ts\", \"norm\", \"ts\", \"stat\")\n            ):",
  "start_line": 361,
  "end_line": 400,
  "total_lines": 872,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "586:    def from_table(cls, table, format=\"\", colname=None):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "gammapy/maps/region/ndmap.py",
  "content": "    def from_table(cls, table, format=\"\", colname=None):\n        \"\"\"Create region map from table.\n\n        Parameters\n        ----------\n        table : `~astropy.table.Table`\n            Table with input data.\n        format : {\"gadf-sed\", \"lightcurve\", \"profile\"}\n            Format to use.\n        colname : str\n            Column name to take the data from.\n\n        Returns\n        -------\n        region_map : `RegionNDMap`\n            Region map.\n        \"\"\"\n        if format == \"gadf-sed\":\n            if colname is None:\n                raise ValueError(\"Column name required\")\n\n            axes = MapAxes.from_table(table=table, format=format)\n\n            if colname == \"stat_scan\":\n                names = [\"norm\", \"energy\"]\n            # TODO: this is not officially supported by GADF...\n            elif colname in [\"counts\", \"npred\", \"npred_excess\"]:\n                names = [\"dataset\", \"energy\"]\n            else:\n                names = [\"energy\"]\n\n            axes = axes[names]\n            data = table[colname].data\n            unit = table[colname].unit or \"\"\n        elif format == \"lightcurve\":",
  "start_line": 586,
  "end_line": 620,
  "total_lines": 837,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "gammapy/maps/region/ndmap.py",
  "content": "            axes = MapAxes.from_table(table=table, format=format)\n\n            if colname == \"stat_scan\":\n                names = [\"norm\", \"energy\", \"time\"]\n            # TODO: this is not officially supported by GADF...\n            elif colname in [\"counts\", \"npred\", \"npred_excess\"]:\n                names = [\"dataset\", \"energy\", \"time\"]\n            else:\n                names = [\"energy\", \"time\"]\n\n            axes = axes[names]\n            data = table[colname].data\n            unit = table[colname].unit or \"\"\n        elif format == \"profile\":\n            axes = MapAxes.from_table(table=table, format=format)\n\n            if colname == \"stat_scan\":\n                names = [\"norm\", \"energy\", \"projected-distance\"]\n            # TODO: this is not officially supported by GADF...\n            elif colname in [\"counts\", \"npred\", \"npred_excess\"]:\n                names = [\"dataset\", \"energy\", \"projected-distance\"]\n            else:\n                names = [\"energy\", \"projected-distance\"]\n\n            axes = axes[names]\n            data = table[colname].data\n            unit = table[colname].unit or \"\"\n        else:\n            raise ValueError(f\"Format not supported {format}\")\n",
  "start_line": 621,
  "end_line": 650,
  "total_lines": 837,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "gammapy/maps/region/ndmap.py",
  "content": "    def from_table(cls, table, format=\"\", colname=None):\n        \"\"\"Create region map from table.\n\n        Parameters\n        ----------\n        table : `~astropy.table.Table`\n            Table with input data.\n        format : {\"gadf-sed\", \"lightcurve\", \"profile\"}\n            Format to use.\n        colname : str\n            Column name to take the data from.\n\n        Returns\n        -------\n        region_map : `RegionNDMap`\n            Region map.\n        \"\"\"\n        if format == \"gadf-sed\":\n            if colname is None:\n                raise ValueError(\"Column name required\")\n\n            axes = MapAxes.from_table(table=table, format=format)\n\n            if colname == \"stat_scan\":\n                names = [\"norm\", \"energy\"]\n            # TODO: this is not officially supported by GADF...\n            elif colname in [\"counts\", \"npred\", \"npred_excess\"]:\n                names = [\"dataset\", \"energy\"]\n            else:\n                names = [\"energy\"]\n\n            axes = axes[names]\n            data = table[colname].data\n            unit = table[colname].unit or \"\"\n        elif format == \"lightcurve\":\n            axes = MapAxes.from_table(table=table, format=format)\n\n            if colname == \"stat_scan\":\n                names = [\"norm\", \"energy\", \"time\"]\n            # TODO: this is not officially supported by GADF...\n            elif colname in [\"counts\", \"npred\", \"npred_excess\"]:\n                names = [\"dataset\", \"energy\", \"time\"]\n            else:\n                names = [\"energy\", \"time\"]\n\n            axes = axes[names]\n            data = table[colname].data\n            unit = table[colname].unit or \"\"\n        elif format == \"profile\":\n            axes = MapAxes.from_table(table=table, format=format)\n\n            if colname == \"stat_scan\":\n                names = [\"norm\", \"energy\", \"projected-distance\"]\n            # TODO: this is not officially supported by GADF...\n            elif colname in [\"counts\", \"npred\", \"npred_excess\"]:\n                names = [\"dataset\", \"energy\", \"projected-distance\"]\n            else:\n                names = [\"energy\", \"projected-distance\"]\n\n            axes = axes[names]\n            data = table[colname].data\n            unit = table[colname].unit or \"\"\n        else:\n            raise ValueError(f\"Format not supported {format}\")\n\n        geom = RegionGeom.create(region=None, axes=axes)\n        data = data.reshape(geom.data_shape)\n        return cls(geom=geom, data=data, unit=unit, meta=table.meta, dtype=data.dtype)\n\n    @classmethod\n    def from_hdulist(cls, hdulist, format=\"gadf\", ogip_column=None, hdu=None, **kwargs):\n        \"\"\"Create from `~astropy.io.fits.HDUList`.\n\n        Parameters\n        ----------",
  "start_line": 586,
  "end_line": 660,
  "total_lines": 837,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "                table[\"norm_scan\"] = norm_axis.center.reshape((1, -1))\n                table[\"stat\"] = self.stat.data[idx]\n                table[\"stat_scan\"] = self.stat_scan.data[idx]\n\n            table[\"is_ul\"] = self.is_ul.data[idx]\n            if not self.has_ul:\n                table.remove_columns(\"is_ul\")\n\n        elif format == \"lightcurve\":\n            time_axis = self.geom.axes[\"time\"]\n\n            tables = []\n            for idx, (time_min, time_max) in enumerate(time_axis.iter_by_edges):\n                table_flat = Table()\n                table_flat[\"time_min\"] = [time_min.mjd]\n                table_flat[\"time_max\"] = [time_max.mjd]\n\n                fp = self.slice_by_idx(slices={\"time\": idx})\n                table = fp.to_table(sed_type=sed_type, format=\"gadf-sed\")\n\n                for column in table.columns:\n                    table_flat[column] = table[column][np.newaxis]\n\n                tables.append(table_flat)\n\n            table = vstack(tables)\n\n            # serialize with reference time set to mjd=0.0\n            ref_time = Time(0.0, format=\"mjd\", scale=time_axis.reference_time.scale)\n            table.meta.update(time_ref_to_dict(ref_time, scale=ref_time.scale))\n            table.meta[\"TIMEUNIT\"] = \"d\"\n\n        elif format == \"binned-time-series\":\n            message = (\n                \"Format 'binned-time-series' support a single time axis \"\n                f\"only. Got {self.geom.axes.names}\"\n            )\n\n            if not self.geom.axes.is_unidimensional:\n                raise ValueError(message)\n\n            axis = self.geom.axes.primary_axis\n\n            if not isinstance(axis, TimeMapAxis):\n                raise ValueError(message)\n\n            table = Table()\n            table[\"time_bin_start\"] = axis.time_min\n            table[\"time_bin_size\"] = axis.time_delta\n\n            for quantity in self.all_quantities(sed_type=sed_type):",
  "start_line": 500,
  "end_line": 550,
  "total_lines": 872,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "31:def squash_fluxpoints(flux_point, axis):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "def squash_fluxpoints(flux_point, axis):\n    \"\"\"Squash a `~FluxPoints` object into one point.\n\n    The log-likelihoods profiles in each bin are summed\n    to compute the resultant quantities. Stat profiles\n    must be present on the `~FluxPoints` object for\n    this method to work.\n    \"\"\"\n    value_scan = flux_point.stat_scan.geom.axes[\"norm\"].center\n    stat_scan = np.sum(flux_point.stat_scan.data, axis=0).ravel()\n    f = interp1d(value_scan, stat_scan, kind=\"quadratic\", bounds_error=False)\n    f = interpolate_profile(value_scan, stat_scan)\n    minimizer = minimize(\n        f,\n        x0=value_scan[int(len(value_scan) / 2)],\n        bounds=[(value_scan[0], value_scan[-1])],\n        method=\"L-BFGS-B\",\n    )\n\n    maps = Maps()\n    geom = flux_point.geom.to_image()\n    if axis.name != \"energy\":\n        geom = geom.to_cube([flux_point.geom.axes[\"energy\"]])\n\n    maps[\"norm\"] = Map.from_geom(geom, data=minimizer.x)\n    maps[\"norm_err\"] = Map.from_geom(\n        geom, data=np.sqrt(minimizer.hess_inv.todense()).reshape(geom.data_shape)\n    )\n    maps[\"n_dof\"] = Map.from_geom(geom, data=flux_point.geom.axes[axis.name].nbin)\n",
  "start_line": 31,
  "end_line": 60,
  "total_lines": 872,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "gammapy/estimators/points/core.py:31:def squash_fluxpoints(flux_point, axis):\ngammapy/estimators/points/core.py:869:            fp_new = squash_fluxpoints(fp, axis_new)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "        if not self.has_stat_profiles:\n            raise ValueError(\"Stat profiles not present, rebinning is not possible\")\n\n        fluxpoints = []\n        for edge_min, edge_max in zip(axis_new.edges_min, axis_new.edges_max):\n            if isinstance(axis_new, TimeMapAxis):\n                edge_min = edge_min + axis_new.reference_time\n                edge_max = edge_max + axis_new.reference_time\n            fp = self.slice_by_coord({axis_new.name: slice(edge_min, edge_max)})\n            fp_new = squash_fluxpoints(fp, axis_new)\n            fluxpoints.append(fp_new)\n\n        return self.__class__.from_stack(fluxpoints, axis=axis_new)",
  "start_line": 860,
  "end_line": 872,
  "total_lines": 872,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "92:class FluxPoints(FluxMaps):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "def squash_fluxpoints(flux_point, axis):\n    \"\"\"Squash a `~FluxPoints` object into one point.\n\n    The log-likelihoods profiles in each bin are summed\n    to compute the resultant quantities. Stat profiles\n    must be present on the `~FluxPoints` object for\n    this method to work.\n    \"\"\"\n    value_scan = flux_point.stat_scan.geom.axes[\"norm\"].center\n    stat_scan = np.sum(flux_point.stat_scan.data, axis=0).ravel()\n    f = interp1d(value_scan, stat_scan, kind=\"quadratic\", bounds_error=False)\n    f = interpolate_profile(value_scan, stat_scan)\n    minimizer = minimize(\n        f,\n        x0=value_scan[int(len(value_scan) / 2)],\n        bounds=[(value_scan[0], value_scan[-1])],\n        method=\"L-BFGS-B\",\n    )\n\n    maps = Maps()\n    geom = flux_point.geom.to_image()\n    if axis.name != \"energy\":\n        geom = geom.to_cube([flux_point.geom.axes[\"energy\"]])\n\n    maps[\"norm\"] = Map.from_geom(geom, data=minimizer.x)\n    maps[\"norm_err\"] = Map.from_geom(\n        geom, data=np.sqrt(minimizer.hess_inv.todense()).reshape(geom.data_shape)\n    )\n    maps[\"n_dof\"] = Map.from_geom(geom, data=flux_point.geom.axes[axis.name].nbin)\n\n    if \"norm_ul\" in flux_point.available_quantities:\n        delta_ts = flux_point.meta.get(\"n_sigma_ul\", 2) ** 2\n        ul = stat_profile_ul_scipy(value_scan, stat_scan, delta_ts=delta_ts)\n        maps[\"norm_ul\"] = Map.from_geom(geom, data=ul.value)\n\n    maps[\"stat\"] = Map.from_geom(geom, data=f(minimizer.x))\n\n    geom_scan = geom.to_cube([MapAxis.from_nodes(value_scan, name=\"norm\")])\n    maps[\"stat_scan\"] = Map.from_geom(\n        geom=geom_scan, data=stat_scan.reshape(geom_scan.data_shape)\n    )\n    try:\n        maps[\"stat_null\"] = Map.from_geom(geom, data=np.sum(flux_point.stat_null.data))\n        maps[\"ts\"] = maps[\"stat_null\"] - maps[\"stat\"]\n    except AttributeError:\n        log.info(\n            \"Stat null info not present on original FluxPoints object. TS not computed\"\n        )\n\n    maps[\"success\"] = Map.from_geom(geom=geom, data=minimizer.success, dtype=bool)",
  "start_line": 31,
  "end_line": 80,
  "total_lines": 872,
  "is_truncated": false,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}