gammapy-plugin 0.0.1__py3-none-any.whl

gammapy_plugin/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for Gammapy Plugin."""
+
+from .gammapy_like import GammapyLike
+
+__all__ = ["GammapyLike"]

gammapy_plugin/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = 'g71c123a'

gammapy_plugin/converter.py

@@ -0,0 +1,276 @@
+import logging
+
+from astromodels.core.model import Model
+from astromodels.sources import ExtendedSource, PointSource, Source
+from gammapy.modeling.models import SkyModel
+
+from gammapy_plugin.models import (
+    PointSourceModelConverted,
+    SpatialModelConverted,
+    SpectralModelConverted,
+)
+from gammapy_plugin.utils.gammapy_parser import (
+    parameter_to_gammapy_dict,
+)
+
+__all__ = ["AstromodelConverter", "SourceConverter"]
+
+log = logging.getLogger(__name__)
+
+
+class AstromodelConverter:
+    """Class for analyizing an astromodel model and converting all the
+    individual sources such that it can be used with gammapy.
+
+    Every Source in the Model will get its own Gammapy skymodel. The
+    evaluation happens via the astromodel definition.
+    """
+
+    def __init__(
+        self, model: Model, frame: str | None = None, convert_ps: bool = True
+    ) -> None:
+        """
+        :param model: the astromodel model
+        :type model: astromodels.core.model.Model
+        :param frame: geometry frame for gammapy, defaults to ICRS, optional
+        :type frame: str
+        :param convert_ps: convert PointSources to a PointSpatialModel, optional
+        :type convert_ps: bool
+        """
+        assert isinstance(model, Model), (
+            "AstromodelConverter needs an astromodels Model"
+        )
+        self._astromodel_model = model
+        if frame is not None:
+            self._frame = frame
+        else:
+            log.info("No frame passed - will use ICRS")
+            self._frame = "icrs"
+        self._convert_ps = convert_ps
+        self._converted_sources = {}
+        self._gammapy_models = []
+        self._convert_extendend_sources()
+        self._convert_point_sources()
+        self._create_gammapy_models_list()
+
+    def _convert_extendend_sources(self) -> None:
+        """Converts all extended sources into individual gammapy skymodels."""
+        for (
+            source_name,
+            source_instance,
+        ) in self._astromodel_model.extended_sources.items():
+            self._converted_sources[source_name] = SourceConverter(
+                source_instance, frame=self._frame, converter=self
+            )
+
+    def _convert_point_sources(self) -> None:
+        """Converts all point sources into individual skymodels."""
+        for (
+            source_name,
+            source_instance,
+        ) in self._astromodel_model.point_sources.items():
+            log.debug(f"Converting pointsource {source_name}")
+            self._converted_sources[source_name] = SourceConverter(
+                source_instance, converter=self, convert_spatial=self._convert_ps
+            )
+
+    def _create_gammapy_models_list(self) -> None:
+        """Creates a list with all SkyModels fro the converted sources."""
+        for source in self._converted_sources.values():
+            self._gammapy_models.append(source.skymodel)
+
+    def _update_parameters(self) -> None:
+        """Update all the parameters in the SkyModels with the values from the
+        astromodels model using the underlying SourceConverters."""
+        for source in self._converted_sources.values():
+            source._update_parameters()
+
+    def update(self) -> None:
+        """Update all parameters of all SkyModels witht the current values from the
+        astromodels model. Public method for _update_parameters"""
+        self._update_parameters()
+
+    @property
+    def gammapy_models(self) -> list[SkyModel]:
+        """
+        Returns all the gammapy skymodels for that model.
+
+        :return: list with all the SkyModels
+        :rtype: list[SkyModel]
+        """
+        return self._gammapy_models
+
+    @property
+    def model(self) -> Model:
+        """
+        Return the corresponding astromodels model
+
+        :return: the astromodels model
+        :rtype: astromodels.core.model.Model
+        """
+
+        return self._astromodel_model
+
+    @property
+    def converted_sources(self) -> dict:
+        """
+        Returns dictionary with all the converted sources.
+
+        :return: the converted sources dict
+        :rtype: dict
+        """
+        return self._converted_sources
+
+
+class SourceConverter:
+    """Takes a astromodels source and converts it to a SkyModel"""
+
+    def __init__(
+        self, source: Source, converter: AstromodelConverter, **kwargs
+    ) -> None:
+        """
+        Initialize the SourceConverter.
+        :param source: The astromodels source
+        :type source: astromodels.core.model.Model
+        :param converter: The used AstromodelConverter instance
+        :type converter: AstromodelConverter
+        :param kwargs: Additional keyword arguments, optional
+        :type kwrags: dict
+        """
+
+        self._conv_spatial = kwargs.get("convert_spatial", True)
+        self._converter = converter
+        self._frame = self._converter._frame
+        self._source = source
+
+        # init everything to None
+        self._spatial_model = None
+        self._spectral_model = None
+        self._temporal_model = None
+        self._gammapy_model = None
+        self._parameter_dict = None
+
+        # start with converting the spatial model
+        if self._conv_spatial:
+            log.debug("Converting the spatial Model")
+            self._convert_spatial_model()
+
+        log.debug("Converting the spectral Model")
+        # converting the spectral model
+        self._convert_spectral_model()
+
+        self._create_skymodel()
+
+    def _gather_mappings(self) -> None:
+        """
+        Gather all the parameter mappings from astromodels to gammapy for the individual
+        spectral and spatial models
+        """
+        self._mapping = None
+        self._mapping_free = None
+        for comp in [self._spectral_model, self._spatial_model]:
+            if comp is not None:
+                if self._mapping is None:
+                    self._mapping = comp.mapping
+                else:
+                    self._mapping.update(comp.mapping)
+                if self._mapping_free is None:
+                    self._mapping_free = comp.mapping_free
+                else:
+                    self._mapping_free.update(comp.mapping_free)
+
+    def _update_parameters(self) -> None:
+        """Update the skymodel parameters during the sampling process using the
+        parameter dict."""
+        # update the parameter dict for this skymodel
+        for k, v in self._mapping_free.items():
+            self.skymodel.parameters[v].update_from_dict(
+                parameter_to_gammapy_dict(self._converter.model[k])
+            )
+
+    def _convert_spectral_model(self) -> None:
+        """Convert the spectral model of the source."""
+        if len(self._source.components.keys()) > 1:
+            self._spectral_model = SpectralModelConverted(
+                [x.shape for x in self._source.components.values()],
+            )
+
+        else:
+            self._spectral_model = SpectralModelConverted(
+                self._source.components[
+                    next(iter(self._source.components.keys()))
+                ].shape,
+            )
+
+    def _convert_spatial_model(self) -> None:
+        """Convert the spatial model of the source."""
+        if isinstance(self._source, ExtendedSource):
+            ps = False
+        elif isinstance(self._source, PointSource):
+            position = self._source.position
+            ps = True
+        if ps:
+            self._spatial_model = PointSourceModelConverted(
+                sky_position=position,
+                frame=self._frame,
+            )
+        else:
+            self._spatial_model = SpatialModelConverted(
+                self._source.spatial_shape, frame=self._frame
+            )
+
+    def _create_skymodel(self) -> None:
+        """Create the skymodel instance out of the individual components."""
+        self._skymodel = SkyModel(
+            name=self._source.name,
+            spectral_model=self._spectral_model,
+            spatial_model=self._spatial_model,
+            temporal_model=self._temporal_model,
+        )
+        self._gather_mappings()
+
+    def update(self) -> None:
+        """
+        This invokes the updating of all parameters of the converted model in the
+        gammapy SkyModels
+        """
+        self._update_parameters()
+
+    @property
+    def skymodel(self) -> SkyModel:
+        """Returns the Gammapy skymodel for this source.
+
+        :returns: the created gammapy SkyModel
+        :rtype: gammapy.modeling.models.SkyModel
+
+        """
+        return self._skymodel
+
+    @property
+    def astromodels_source(self) -> Source:
+        """Returns the original astromodel source.
+
+        :returns: the converted astromodels Source
+        :rtype: astromodels.sources.Source
+        """
+
+        return self._source
+
+
+class GammapyConverter:  # pragma: no cover
+    """Takes a gammapy SkyModel and transforms it into a astromodels Model."""
+
+    def __init__(self, model: SkyModel) -> None:
+        assert isinstance(model, SkyModel), "You must provide a gammapy.model.SkyModel"
+        self._sky_model = model
+        raise NotImplementedError("Sorry this is not yet a feature :(")
+
+    def _parse_sources(self):
+        spectral_model = self._sky_model.spectral_model  # noqa: F841
+        spatial_model = self._sky_model.spatial_model  # noqa: F841
+
+    def _create_astromodel(self):
+        # load the sources
+        # load the
+        sources = []
+        self._astromodel = Model(*sources)

gammapy_plugin/gammapy_like.py

@@ -0,0 +1,325 @@
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import gammapy
+import numpy as np
+from astromodels.core.model import Model
+from astromodels.functions.priors import Truncated_gaussian
+from gammapy.datasets import Dataset, Datasets
+from gammapy.modeling.models import DatasetModels, ModelBase, Models
+from packaging.version import Version
+from threeML.plugin_prototype import PluginPrototype
+
+from gammapy_plugin.converter import AstromodelConverter
+from gammapy_plugin.io.plot_model import plot_model
+from gammapy_plugin.utils.gammapy_parser import (
+    parameter_to_gammapy_dict,
+    parse_gammapy_model,
+)
+
+if TYPE_CHECKING:
+    from threeML.io.plotting.data_residual_plot import ResidualPlot
+
+
+__all__ = ["GammapyLike"]
+
+log = logging.getLogger(__name__)
+
+__instrument_name = "gammapy"
+
+gammapy_version = Version(gammapy.__version__)
+
+
+class GammapyLike(PluginPrototype):
+    """A plugin for including Gammapy datasets."""
+
+    def __new__(cls, *args, **kwargs) -> PluginPrototype:
+        instance = object.__new__(cls)
+        return instance
+
+    def __init__(self, name: str, **kwargs) -> None:
+        """
+        Initialize the GammapyLike plugin.
+
+        :param name: Name of the plugin
+        :type name: str
+        """
+        nuisance_parameters = kwargs.get("nuisance_parameters", {})
+        super().__init__(name, nuisance_parameters=nuisance_parameters)
+        self._frame: str = kwargs.get("frame", "icrs")
+        self._sources: list[str] | None = kwargs.get("sources", None)
+        self._nuisance_mapping = {}
+        self._background_models: dict = kwargs.get("background_models", {})
+        self._background_models_mapper: dict = {}
+        self._nuisance_parameters_dicts: dict = {}
+        if len(self._background_models.keys()) > 0:
+            self._parse_background_models()
+
+    def set_datasets(
+        self,
+        datasets: Dataset | Datasets | list[Dataset] | Path | str,
+        mode: str = "individual",
+        stacked_name: str = "stacked",
+    ) -> None:
+        """Set the Gammapy Dataset.
+
+        :param datasets: list of Gammapy datasets or a single Dataset object
+        :param mode: individual or stacked - defaults to individual, stacked
+            stacks the passed datasets
+        :param stacked_name: name of the stacked datasset if mode is stacked
+        """
+        if mode not in [
+            "individual",
+            "stacked",
+        ]:
+            raise ValueError("mode needs to be individual or stacked")
+        if isinstance(datasets, (str, Path)):
+            log.warning(
+                "You have provided a path to a file - we will assume this is a Datasets"
+                " file. If not this will likely fail"
+            )
+            datasets = Datasets.read(datasets)
+            self._datasets = datasets
+            if mode == "stacked":
+                self._datasets = Datasets(
+                    self._datasets.stack_reduce(name=stacked_name)
+                )
+
+        if isinstance(datasets, list):
+            self._datasets = Datasets()
+            for d in datasets:
+                self._datasets.append(d)
+            if mode == "stacked":
+                self._datasets = Datasets(
+                    self._datasets.stack_reduce(name=stacked_name)
+                )
+
+        elif isinstance(datasets, Datasets):
+            self._datasets = datasets
+            if mode == "stacked":
+                self._datasets = Datasets(
+                    self._datasets.stack_reduce(name=stacked_name)
+                )
+        elif isinstance(datasets, Dataset):
+            self._datasets = Datasets(datasets)
+            if mode == "stacked":
+                log.info("Only using a single dataset - can not stack that")
+        else:
+            msg = "datasets has to be list of Dataset,"
+            msg += " a single Datasets or Dataset object"
+            raise TypeError(msg)
+
+    def set_sources(self, sources: list[str] | str | None = None) -> None:
+        """
+        Set the sources to be used by this plugin - No need to specify bkg models
+
+        :param sources: Source(s) to be used in the analysis defaults to all
+        :type sources: list of str or str
+        """
+
+        if isinstance(sources, list):
+            self._sources = sources
+        elif isinstance(sources, str):
+            self._sources = [sources]
+        elif sources is None:
+            self._sources = None
+        else:
+            raise ValueError("")
+
+    def set_model(
+        self,
+        likelihood_model: Model,
+        converted_model: AstromodelConverter = None,
+    ) -> None:
+        """
+        Set the model to be used in the joint minimization.
+
+        :param likelihood_model: astromodels model
+        :param converted_model: converted astromodels
+        :type likelihood_model: Model
+        :type converted_model: AstromodelConverter
+        """
+
+        if self._sources is None:
+            log.debug(
+                "If you want to specify sources for this Plugin you MUST do so before"
+            )
+        else:
+            log.debug(f"Will use {self._sources} for this plugin")
+
+        self._likelihood_model: Model = likelihood_model
+        if converted_model is not None:
+            self._likelihood_model_converted: AstromodelConverter = converted_model
+        elif hasattr(self, "_likelihood_model_converted"):
+            pass
+        else:
+            self._likelihood_model_converted: AstromodelConverter = AstromodelConverter(
+                model=self._likelihood_model, frame=self._frame
+            )
+
+        self._update_gammapy_model_list()
+        self._assign_models()
+        self._set_get_log_like()
+
+    def _update_gammapy_model_list(self) -> Models:
+        """
+        Update the list of gammapy models.
+        """
+
+        # this will only be run after setting the model
+        if hasattr(self, "_likelihood_model_converted"):
+            if self._sources is not None:
+                tmp2 = [
+                    x
+                    for x in self._likelihood_model_converted.gammapy_models
+                    if x.name in self._sources
+                ]
+
+                tmp = [*tmp2]
+            else:
+                tmp2 = [x for x in self._likelihood_model_converted.gammapy_models]
+                tmp = [*tmp2]
+        else:
+            tmp = []
+            tmp2 = []
+        self._global_models = Models(tmp2)
+        if hasattr(self, "_background_models"):
+            for m in list(self._background_models.values()):
+                tmp.append(m)
+        self._gammapy_model = Models(tmp)
+
+    def _assign_models(self):
+        """
+        Assign the gammapy models to the datasets
+        """
+        for d in self._datasets:
+            d.models = []
+            tmp = list(self._global_models).copy()
+            if d.name in self._background_models_mapper:
+                tmp.append(
+                    self._background_models[self._background_models_mapper[d.name]]
+                )
+            d.models = Models(tmp)
+
+    def set_background_models(
+        self, bkg_model: ModelBase | list | Models | DatasetModels
+    ) -> None:
+        """
+        Set the gammapy background models (e.g. FoVBackgroundModel)
+
+        :param bkg_model: Background model(s) :type bkg_model: ModelBase or list of
+            ModelBase or Models or DatasetModels.
+        """
+        if isinstance(bkg_model, ModelBase):
+            bkg_model = [bkg_model]
+        else:
+            if not isinstance(bkg_model, (list, Models, DatasetModels)):
+                raise TypeError(
+                    "either pass a singular gammapy model or a list of models"
+                )
+        for b in bkg_model:
+            self._background_models[b.name] = b
+            self._background_models_mapper[b.datasets_names[0]] = b.name
+        self._parse_background_models()
+        self._update_gammapy_model_list()
+        self._assign_models()
+
+    def _parse_background_models(self):
+        """
+        Parse the background models and link the gammapy parameters to
+        nuissance parameters of this plugin and set the prior.
+        """
+        # TODO: way of manually specifying the priors
+        for bkg in self._background_models.values():
+            bkg_paras = parse_gammapy_model(bkg, self._name)
+            for k, v in bkg_paras.items():
+                para_path = k.split(".")
+                self._nuisance_mapping[k] = para_path
+                self._nuisance_parameters[k] = v
+                if v.is_normalization and v.free:
+                    self._nuisance_parameters[k].prior = Truncated_gaussian(
+                        mu=1.0, sigma=0.1, lower_bound=0.2, upper_bound=1.8
+                    )
+                self._nuisance_parameters_dicts[k] = parameter_to_gammapy_dict(v)
+
+    def _update_background_models(self):
+        """
+        Update the background models with the current values of the nuisance
+        parameters.
+        """
+        # TODO: rewrite this to directly update
+        for k, v in self._nuisance_parameters.items():
+            self._nuisance_parameters_dicts[k]["value"] = v.value
+            p = self._nuisance_mapping[k]
+            # TODO find an elegant way to not hardcode this
+            self._background_models[p[1]].parameters[p[2]].update_from_dict(
+                self._nuisance_parameters_dicts[k]
+            )
+
+    def _set_get_log_like(self):
+        if hasattr(self._datasets, "_stat_sum_likelihood"):
+            func = self._datasets._stat_sum_likelihood
+        elif hasattr(self._datasets, "stat_sum_likelihood"):
+            func = self._datasets.stat_sum_likelihood
+        else:
+            raise AttributeError(
+                "gammapy.Datasets has neither _stat_sum_likelihood nor "
+                "stat_sum_likelihood - something went fundamentally wrong!"
+            )
+
+        self.log_like_func = func
+
+    def get_log_like(self) -> float:
+        """
+        Return the value of the log-likelihood with the current values for
+        the parameters stored in the model instance.
+        """
+        self._likelihood_model_converted._update_parameters()
+        self._update_background_models()
+        return -0.5 * self.log_like_func()
+
+    def inner_fit(self):
+        return self.get_log_like()
+
+    def get_number_of_data_points(self) -> np.int64:
+        """
+        Return the number of data points in the datasets.
+        """
+        return np.sum([np.prod(d.counts.data.shape) for d in self._datasets])
+
+    @property
+    def datasets(self) -> Datasets:
+        """Gammapy datasets of the plugin."""
+        return self._datasets
+
+    @property
+    def model(self) -> Model:
+        """Astromodels model of the plugin."""
+        return self._likelihood_model
+
+    @property
+    def astromodel_converter(self) -> AstromodelConverter:
+        """AstromodelConverter object used for this plugin."""
+        return self._likelihood_model_converted
+
+    @property
+    def gammapy_model(self) -> Models:
+        """List of all the Gammapy SkyModels."""
+
+        if not hasattr(self, "_gammapy_model"):
+            self._update_gammapy_model_list()
+        return self._gammapy_model
+
+    @property
+    def frame(self) -> str:
+        """Coordinate Frame of the plugin."""
+        return self._frame
+
+    def display_model(
+        self,
+        *args,
+        **kwargs,
+    ) -> "ResidualPlot":
+
+        return plot_model(self._datasets, *args, **kwargs)