gammapy__gammapy-5674

{
  "status": "ok",
  "stdout": "./gammapy/estimators/points/core.py: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\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,\n        sed_type=None,",
  "start_line": 31,
  "end_line": 180,
  "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": "        **kwargs : dict, optional\n            Keyword arguments passed to `~scipy.optimize.brentq`.\n\n        Returns\n        -------\n        flux_points : `~gammapy.estimators.FluxPoints`\n            A new FluxPoints object with modified upper limits.\n\n        Examples\n        --------\n        >>> from gammapy.estimators import FluxPoints\n        >>> filename = '$GAMMAPY_DATA/tests/spectrum/flux_points/binlike.fits'\n        >>> flux_points = FluxPoints.read(filename)\n        >>> flux_points_recomputed = flux_points.recompute_ul(n_sigma_ul=3)\n        >>> print(flux_points.meta[\"n_sigma_ul\"], flux_points.flux_ul.data[0])\n        2.0 [[3.95451985e-09]]\n        >>> print(flux_points_recomputed.meta[\"n_sigma_ul\"], flux_points_recomputed.flux_ul.data[0])\n        3 [[6.22245374e-09]]\n        \"\"\"\n        if not self.has_stat_profiles:\n            raise ValueError(\n                \"Stat profiles not present. Upper limit computation is not possible\"\n            )\n\n        delta_ts = n_sigma_ul**2\n\n        flux_points = deepcopy(self)\n\n        value_scan = self.stat_scan.geom.axes[\"norm\"].center\n        shape_axes = self.stat_scan.geom._shape[slice(3, None)][::-1]\n        for idx in np.ndindex(shape_axes):\n            stat_scan = np.abs(\n                self.stat_scan.data[idx].squeeze() - self.stat.data[idx].squeeze()\n            )\n            flux_points.norm_ul.data[idx] = stat_profile_ul_scipy(\n                value_scan, stat_scan, delta_ts=delta_ts, **kwargs\n            )\n        flux_points.meta[\"n_sigma_ul\"] = n_sigma_ul\n        return flux_points\n\n    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": 800,
  "end_line": 872,
  "total_lines": 872,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "gammapy/estimators/tests/:\n__init__.py\ntest_core.py\ntest_energydependentmorphology.py\ntest_flux.py\ntest_metadata.py\ntest_parameter_estimator.py\ntest_profile.py\ntest_utils.py\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "gammapy/utils/interpolation.py",
  "content": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\n\"\"\"Interpolation utilities.\"\"\"\n\nimport html\nfrom itertools import compress\nimport numpy as np\nimport scipy.interpolate\nfrom astropy import units as u\nfrom .compat import COPY_IF_NEEDED\n\n__all__ = [\n    \"interpolate_profile\",\n    \"interpolation_scale\",\n    \"ScaledRegularGridInterpolator\",\n]\n\nINTERPOLATION_ORDER = {None: 0, \"nearest\": 0, \"linear\": 1, \"quadratic\": 2, \"cubic\": 3}\n\n\nclass ScaledRegularGridInterpolator:\n    \"\"\"Thin wrapper around `scipy.interpolate.RegularGridInterpolator`.\n\n    The values are scaled before the interpolation and back-scaled after the\n    interpolation.\n\n    Dimensions of length 1 are ignored in the interpolation of the data.\n\n    Parameters\n    ----------\n    points : tuple of `~numpy.ndarray` or `~astropy.units.Quantity`\n        Tuple of points passed to `RegularGridInterpolator`.\n    values : `~numpy.ndarray`\n        Values passed to `RegularGridInterpolator`.\n    points_scale : tuple of str\n        Interpolation scale used for the points.\n    values_scale : {'lin', 'log', 'sqrt'}\n        Interpolation scaling applied to values. If the values vary over many magnitudes\n        a 'log' scaling is recommended.\n    axis : int or None\n        Axis along which to interpolate.\n    method : {\"linear\", \"nearest\"}\n        Default interpolation method. Can be overwritten when calling the\n        `ScaledRegularGridInterpolator`.\n    **kwargs : dict\n        Keyword arguments passed to `RegularGridInterpolator`.\n    \"\"\"\n\n    def __init__(\n        self,\n        points,\n        values,\n        points_scale=None,\n        values_scale=\"lin\",\n        extrapolate=True,\n        axis=None,\n        **kwargs,\n    ):\n        if points_scale is None:\n            points_scale = [\"lin\"] * len(points)\n\n        self.scale_points = [interpolation_scale(scale) for scale in points_scale]\n        self.scale = interpolation_scale(values_scale)\n        self.axis = axis\n\n        self._include_dimensions = [len(p) > 1 for p in points]\n\n        values_scaled = self.scale(values)\n        points_scaled = self._scale_points(points=points)\n\n        kwargs.setdefault(\"bounds_error\", False)\n\n        if extrapolate:\n            kwargs.setdefault(\"fill_value\", None)\n\n        method = kwargs.get(\"method\", None)\n\n        if not np.any(self._include_dimensions):\n            if method != \"nearest\":\n                raise ValueError(\n                    \"Interpolating scalar values requires using \"\n                    \"method='nearest' explicitly.\"\n                )\n\n        if np.any(self._include_dimensions):\n            values_scaled = np.squeeze(values_scaled)\n\n        if axis is None:\n            self._interpolate = scipy.interpolate.RegularGridInterpolator(\n                points=points_scaled, values=values_scaled, **kwargs\n            )\n        else:\n            self._interpolate = scipy.interpolate.interp1d(\n                points_scaled[0], values_scaled, axis=axis\n            )\n\n    def _repr_html_(self):\n        try:\n            return self.to_html()\n        except AttributeError:\n            return f\"<pre>{html.escape(str(self))}</pre>\"\n\n    def _scale_points(self, points):\n        points_scaled = [scale(p) for p, scale in zip(points, self.scale_points)]\n\n        if np.any(self._include_dimensions):\n            points_scaled = compress(points_scaled, self._include_dimensions)\n\n        return tuple(points_scaled)\n\n    def __call__(self, points, method=None, clip=True, **kwargs):\n        \"\"\"Interpolate data points.\n\n        Parameters\n        ----------\n        points : tuple of `~numpy.ndarray` or `~astropy.units.Quantity`\n            Tuple of coordinate arrays of the form (x_1, x_2, x_3, ...). Arrays are\n            broadcast internally.\n        method : {None, \"linear\", \"nearest\"}\n            Linear or nearest neighbour interpolation.\n            Default is None, which is `method` defined on init.\n        clip : bool\n            Clip values at zero after interpolation.\n        \"\"\"\n        points = self._scale_points(points=points)\n\n        if self.axis is None:\n            points = np.broadcast_arrays(*points)\n            points_interp = np.stack([_.flat for _ in points]).T\n            values = self._interpolate(points_interp, method, **kwargs)\n            values = self.scale.inverse(values.reshape(points[0].shape))\n        else:\n            values = self._interpolate(points[0])\n            values = self.scale.inverse(values)\n\n        if clip:\n            values = np.clip(values, 0, np.inf)\n\n        return values\n\n\ndef interpolation_scale(scale=\"lin\"):\n    \"\"\"Interpolation scaling.\n\n    Parameters\n    ----------\n    scale : {\"lin\", \"log\", \"sqrt\"}\n        Choose interpolation scaling.\n    \"\"\"\n    if scale in [\"lin\", \"linear\"]:\n        return LinearScale()",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 273,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "gammapy/utils/interpolation.py",
  "content": "    elif scale == \"log\":\n        return LogScale()\n    elif scale == \"sqrt\":\n        return SqrtScale()\n    elif scale == \"stat-profile\":\n        return StatProfileScale()\n    elif isinstance(scale, InterpolationScale):\n        return scale\n    else:\n        raise ValueError(f\"Not a valid value scaling mode: '{scale}'.\")\n\n\nclass InterpolationScale:\n    \"\"\"Interpolation scale base class.\"\"\"\n\n    def __call__(self, values):\n        if hasattr(self, \"_unit\"):\n            values = u.Quantity(values, copy=COPY_IF_NEEDED).to_value(self._unit)\n        else:\n            if isinstance(values, u.Quantity):\n                self._unit = values.unit\n                values = values.value\n        return self._scale(values)\n\n    def _repr_html_(self):\n        try:\n            return self.to_html()\n        except AttributeError:\n            return f\"<pre>{html.escape(str(self))}</pre>\"\n\n    def inverse(self, values):\n        values = self._inverse(values)\n        if hasattr(self, \"_unit\"):\n            return u.Quantity(values, self._unit, copy=COPY_IF_NEEDED)\n        else:\n            return values\n\n\nclass LogScale(InterpolationScale):\n    \"\"\"Logarithmic scaling.\"\"\"\n\n    tiny = np.finfo(np.float32).tiny\n\n    def _scale(self, values):\n        values = np.clip(values, self.tiny, np.inf)\n        return np.log(values)\n\n    @classmethod\n    def _inverse(cls, values):\n        output = np.exp(values)\n        return np.where(abs(output) - cls.tiny <= cls.tiny, 0, output)\n\n\nclass SqrtScale(InterpolationScale):\n    \"\"\"Square root scaling.\"\"\"\n\n    @staticmethod\n    def _scale(values):\n        sign = np.sign(values)\n        return sign * np.sqrt(sign * values)\n\n    @classmethod\n    def _inverse(cls, values):\n        return np.power(values, 2)\n\n\nclass StatProfileScale(InterpolationScale):\n    \"\"\"Square root profile scaling.\"\"\"\n\n    def __init__(self, axis=0):\n        self.axis = axis\n\n    def _scale(self, values):\n        values = np.sign(np.gradient(values, axis=self.axis)) * values\n        sign = np.sign(values)\n        return sign * np.sqrt(sign * values)\n\n    @classmethod\n    def _inverse(cls, values):\n        return np.power(values, 2)\n\n\nclass LinearScale(InterpolationScale):\n    \"\"\"Linear scaling.\"\"\"\n\n    @staticmethod\n    def _scale(values):\n        return values\n\n    @classmethod\n    def _inverse(cls, values):\n        return values\n\n\ndef interpolate_profile(x, y, interp_scale=\"sqrt\", extrapolate=False):\n    \"\"\"Helper function to interpolate one-dimensional profiles.\n\n    Parameters\n    ----------\n    x : `~numpy.ndarray`\n        Array of x values.\n    y : `~numpy.ndarray`\n        Array of y values.\n    interp_scale : {\"sqrt\", \"lin\"}\n        Interpolation scale applied to the profile. If the profile is\n        of parabolic shape, a \"sqrt\" scaling is recommended. In other cases or\n        for fine sampled profiles a \"lin\" can also be used.\n        Default is \"sqrt\".\n    extrapolate : bool\n        Extrapolate or not if the evaluation value is outside the range of x values.\n        Default is False.\n\n    Returns\n    -------\n    interp : `interp1d`\n        Interpolator.\n    \"\"\"\n    method_dict = {\"sqrt\": \"quadratic\", \"lin\": \"linear\"}\n    kwargs = dict(kind=method_dict[interp_scale])\n    if extrapolate:\n        kwargs[\"bounds_error\"] = False\n        kwargs[\"fill_value\"] = \"extrapolate\"\n    return scipy.interpolate.interp1d(x, y, **kwargs)",
  "start_line": 151,
  "end_line": 273,
  "total_lines": 273,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "gammapy/estimators/points/core.py",
  "content": "                else:\n                    fp = hdulist[\"\"]  # to handle older files\n                table = Table.read(fp)\n                if \"GTI\" in hdulist:\n                    gti = GTI.from_table_hdu(hdulist[\"GTI\"])\n\n        return cls.from_table(\n            table=table,\n            sed_type=sed_type,\n            reference_model=reference_model,\n            format=format,\n            gti=gti,\n        )\n\n    def write(\n        self, filename, sed_type=None, format=None, overwrite=False, checksum=False\n    ):\n        \"\"\"Write flux points.\n\n        Parameters\n        ----------\n        filename : str\n            Filename.\n        sed_type : {\"dnde\", \"flux\", \"eflux\", \"e2dnde\", \"likelihood\"}, optional\n            SED type. Default is None.\n        format : {\"gadf-sed\", \"lightcurve\", \"binned-time-series\", \"profile\"}, optional\n            Format specification. The following formats are supported:\n\n                * \"gadf-sed\": format for SED flux points see :ref:`gadf:flux-points`\n                  for details\n                * \"lightcurve\": Gammapy internal format to store energy dependent\n                  lightcurves. Basically a generalisation of the \"gadf\" format, but\n                  currently there is no detailed documentation available.\n                * \"binned-time-series\": table format support by Astropy's\n                  `~astropy.timeseries.BinnedTimeSeries`.\n                * \"profile\": Gammapy internal format to store energy dependent\n                  flux profiles. Basically a generalisation of the \"gadf\" format, but\n                  currently there is no detailed documentation available.\n\n                If None, the format will be guessed by looking at the axes that are present in the object.\n                Default is None.",
  "start_line": 220,
  "end_line": 260,
  "total_lines": 872,
  "is_truncated": false
}

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

{
  "status": "error",
  "error_type": "FileReadError",
  "error_message": "404 Client Error for http+docker://localhost/v1.52/containers/88a3fcfa24bf36dba6b18a3705509ffe6e81f2cab3a150b2bb315984bd32ec82/archive?path=%2Fworkspace%2F%22%3A%22: Not Found (\"Could not find the file /workspace/\":\" in container 88a3fcfa24bf36dba6b18a3705509ffe6e81f2cab3a150b2bb315984bd32ec82\")"
}

{
  "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)\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",
  "start_line": 31,
  "end_line": 130,
  "total_lines": 872,
  "is_truncated": false
}