Datasets names follow up

gammapy/cube/fit.py

@@ -89,8 +89,6 @@ def __init__(
             raise ValueError("mask data must have dtype bool")
 
         self._name = make_name(name)
-        self._evaluators = {}
-
         self.background_model = None
         self.evaluation_mode = evaluation_mode
         self.counts = counts
@@ -170,15 +168,15 @@ def __str__(self):
         str_ += "\t{:32}: {:.2f}\n\n".format("Fit statistic value (-2 log(L))", stat)
 
         # model section
-        n_models = 0
+        n_models, n_pars, n_free_pars = 0, 0, 0
         if self.models is not None:
             n_models = len(self.models)
+            n_pars = len(self.models.parameters)
+            n_free_pars = len(self.models.parameters.free_parameters)
 
         str_ += "\t{:32}: {} \n".format("Number of models", n_models)
-        str_ += "\t{:32}: {}\n".format("Number of parameters", len(self.parameters))
-        str_ += "\t{:32}: {}\n\n".format(
-            "Number of free parameters", len(self.parameters.free_parameters)
-        )
+        str_ += "\t{:32}: {}\n".format("Number of parameters", n_pars)
+        str_ += "\t{:32}: {}\n\n".format("Number of free parameters", n_free_pars)
 
         if self.models is not None:
             str_ += "\t" + "\n\t".join(str(self.models).split("\n")[2:])
@@ -195,26 +193,19 @@ def models(self, models):
         if models is None:
             self._models = None
         else:
-            if isinstance(models, (BackgroundModel, SkyModel)):
-                models = [models]
-            elif isinstance(models,(Models, list)):
-                models = list(models)
-            else:
-                raise TypeError("Invalid models")
-            models_list = [
-                model
-                for model in models
-                if self.name in model.datasets_names or model.datasets_names == "all"
-            ]
-            self._models = Models(models_list)
+            self._models = Models(models)
 
+        # TODO: clean this up (probably by removing)
         if self.models is not None:
             for model in self.models:
                 if isinstance(model, BackgroundModel):
-                    self.background_model = model
-                    break
+                    if model.datasets_names is not None:
+                        if self.name in model.datasets_names:
+                            self.background_model = model
+                            break
             else:
                 log.warning(f"No background model defined for dataset {self.name}")
+        self._evaluators = {}
 
     @property
     def evaluators(self):
@@ -225,11 +216,6 @@ def evaluators(self):
 
         return self._evaluators
 
-    @property
-    def parameters(self):
-        """List of parameters (`~gammapy.modeling.Parameters`)"""
-        return self.models.parameters
-
     @property
     def _geom(self):
         """Main analysis geometry"""
@@ -258,6 +244,10 @@ def npred(self):
 
         if self.models:
             for model in self.models:
+                if model.datasets_names is not None:
+                    if self.name not in model.datasets_names:
+                        continue
+
                 evaluator = self._evaluators.get(model.name)
 
                 if evaluator is None:
@@ -318,7 +308,7 @@ def from_geoms(
         kwargs["counts"] = Map.from_geom(geom, unit="")
 
         background = Map.from_geom(geom, unit="")
-        kwargs["models"] = Models([BackgroundModel(background, datasets_names=[name])])
+        kwargs["models"] = Models([BackgroundModel(background, name=name + "-bkg", datasets_names=[name])])
         kwargs["exposure"] = Map.from_geom(geom_exposure, unit="m2 s")
         kwargs["edisp"] = EDispMap.from_geom(geom_edisp)
         kwargs["psf"] = PSFMap.from_geom(geom_psf)
@@ -951,7 +941,9 @@ def cutout(self, position, width, mode="trim", name=None):
             kwargs["exposure"] = self.exposure.cutout(**cutout_kwargs)
 
         if self.background_model is not None:
-            kwargs["models"] = self.background_model.cutout(**cutout_kwargs, name=name)
+            model = self.background_model.cutout(**cutout_kwargs, name=name + "-bkg")
+            model.datasets_names = [name]
+            kwargs["models"] = model
 
         if self.edisp is not None:
             kwargs["edisp"] = self.edisp.cutout(**cutout_kwargs)

gammapy/cube/fov.py

@@ -87,8 +87,8 @@ def _fit_bkg(self, dataset):
             )
 
         # Unfreeze parameters
-        for i, par in enumerate(datasets.parameters):
-            par.frozen = parameters_frozen[i]
+        for idx, par in enumerate(datasets.parameters):
+            par.frozen = parameters_frozen[idx]
 
     def _scale_bkg(self, dataset):
         """Fit the FoV background model on the dataset counts data"""

gammapy/cube/make.py

@@ -231,7 +231,9 @@ def run(self, dataset, observation):
 
         if "background" in self.selection:
             background_map = self.make_background(dataset.counts.geom, observation)
-            kwargs["models"] = BackgroundModel(background_map, datasets_names=[dataset.name])
+            kwargs["models"] = BackgroundModel(
+                background_map, name=dataset.name + "-bkg", datasets_names=[dataset.name]
+            )
 
         if "psf" in self.selection:
             psf = self.make_psf(dataset.psf.psf_map.geom, observation)

gammapy/cube/simulate.py

@@ -65,7 +65,7 @@ def simulate_dataset(
         pointing=pointing, ontime=livetime, bkg=irfs["bkg"], geom=geom
     )
 
-    background_model = BackgroundModel(background)
+    background_model = BackgroundModel(background, datasets_names=["dataset"])
 
     psf = irfs["psf"].to_energy_dependent_table_psf(theta=offset)
     psf_map = PSFMap.from_energy_dependent_table_psf(psf)
@@ -85,6 +85,7 @@ def simulate_dataset(
         exposure=exposure,
         psf=psf_map,
         edisp=edisp,
+        name="dataset"
     )
 
     npred_map = dataset.npred()

gammapy/cube/tests/test_fit.py

@@ -96,12 +96,12 @@ def sky_model():
     return SkyModel(spatial_model=spatial_model, spectral_model=spectral_model)
 
 
-def get_map_dataset(sky_model, geom, geom_etrue, edisp=True, **kwargs):
+def get_map_dataset(sky_model, geom, geom_etrue, edisp=True, name="test", **kwargs):
     """Returns a MapDatasets"""
     # define background model
     m = Map.from_geom(geom)
     m.quantity = 0.2 * np.ones(m.data.shape)
-    background_model = BackgroundModel(m)
+    background_model = BackgroundModel(m, datasets_names=[name])
 
     psf = get_psf()
     exposure = get_exposure(geom_etrue)
@@ -125,6 +125,7 @@ def get_map_dataset(sky_model, geom, geom_etrue, edisp=True, **kwargs):
         psf=psf,
         edisp=edisp,
         mask_fit=mask_fit,
+        name=name,
         **kwargs
     )
 
@@ -182,6 +183,7 @@ def test_different_exposure_unit(sky_model, geom):
 @requires_data()
 def test_to_spectrum_dataset(sky_model, geom, geom_etrue):
     dataset_ref = get_map_dataset(sky_model, geom, geom_etrue, edisp=True)
+    print(dataset_ref)
     dataset_ref.counts = dataset_ref.background_model.map * 0.0
     dataset_ref.counts.data[1, 50, 50] = 1
     dataset_ref.counts.data[1, 60, 50] = 1
@@ -215,13 +217,13 @@ def test_to_image(geom):
     background = Map.read(
         "$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-background-cube.fits.gz"
     )
-    background = BackgroundModel(background)
+    background = BackgroundModel(background, datasets_names=["fermi"])
 
     exposure = Map.read(
         "$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-exposure-cube.fits.gz"
     )
     exposure = exposure.sum_over_axes(keepdims=True)
-    dataset = MapDataset(counts=counts, models=[background], exposure=exposure)
+    dataset = MapDataset(counts=counts, models=[background], exposure=exposure, name="fermi")
     dataset_im = dataset.to_image()
     assert dataset_im.mask_safe is None
     assert dataset_im.counts.data.sum() == dataset.counts.data.sum()
@@ -337,11 +339,11 @@ def test_map_dataset_fits_io(tmp_path, sky_model, geom, geom_etrue):
 @requires_dependency("matplotlib")
 @requires_data()
 def test_map_fit(sky_model, geom, geom_etrue):
-    dataset_1 = get_map_dataset(sky_model, geom, geom_etrue, evaluation_mode="local")
+    dataset_1 = get_map_dataset(sky_model, geom, geom_etrue, evaluation_mode="local", name="test-1")
     dataset_1.background_model.norm.value = 0.5
     dataset_1.counts = dataset_1.npred()
 
-    dataset_2 = get_map_dataset(sky_model, geom, geom_etrue, evaluation_mode="global")
+    dataset_2 = get_map_dataset(sky_model, geom, geom_etrue, evaluation_mode="global", name="test-2")
     dataset_2.counts = dataset_2.npred()
 
     sky_model.parameters["sigma"].frozen = True
@@ -466,7 +468,7 @@ def test_create(geom, geom_etrue):
 def test_stack(geom, geom_etrue):
     m = Map.from_geom(geom)
     m.quantity = 0.2 * np.ones(m.data.shape)
-    background_model1 = BackgroundModel(m, name="dataset-1-bkg")
+    background_model1 = BackgroundModel(m, name="dataset-1-bkg", datasets_names=["dataset-1"])
     c_map1 = Map.from_geom(geom)
     c_map1.quantity = 0.3 * np.ones(c_map1.data.shape)
     mask1 = np.ones(m.data.shape, dtype=bool)
@@ -483,7 +485,7 @@ def test_stack(geom, geom_etrue):
 
     c_map2 = Map.from_geom(geom)
     c_map2.quantity = 0.1 * np.ones(c_map2.data.shape)
-    background_model2 = BackgroundModel(m, norm=0.5, name="dataset-2-bkg")
+    background_model2 = BackgroundModel(m, norm=0.5, name="dataset-2-bkg", datasets_names=["dataset-2"])
     mask2 = np.ones(m.data.shape, dtype=bool)
     mask2[0][3] = False
     mask2 = Map.from_geom(geom, data=mask2)
@@ -772,7 +774,7 @@ def test_names(geom, geom_etrue, sky_model):
 
     m = Map.from_geom(geom)
     m.quantity = 0.2 * np.ones(m.data.shape)
-    background_model1 = BackgroundModel(m, name="bkg1")
+    background_model1 = BackgroundModel(m, name="bkg1", datasets_names=["test"])
     assert background_model1.name == "bkg1"
 
     c_map1 = Map.from_geom(geom)
@@ -788,6 +790,7 @@ def test_names(geom, geom_etrue, sky_model):
         counts=c_map1,
         models=Models([model1, model2, background_model1]),
         exposure=get_exposure(geom_etrue),
+        name="test"
     )
 
     dataset2 = dataset1.copy()

gammapy/cube/tests/test_fov.py

@@ -58,7 +58,7 @@ def obs_dataset(geom, observation):
     map_dataset_maker = MapDatasetMaker(selection=["counts", "background", "exposure"])
 
     reference = MapDataset.create(geom)
-    cutout = reference.cutout(observation.pointing_radec, width="4 deg")
+    cutout = reference.cutout(observation.pointing_radec, width="4 deg", name="test-fov")
 
     dataset = map_dataset_maker.run(cutout, observation)
     dataset = safe_mask_maker.run(dataset, observation)
@@ -74,7 +74,7 @@ def test_fov_bkg_maker_incorrect_method():
 def test_fov_bkg_maker_scale(obs_dataset, exclusion_mask):
     fov_bkg_maker = FoVBackgroundMaker(method="scale", exclusion_mask=exclusion_mask)
 
-    test_dataset = obs_dataset.copy()
+    test_dataset = obs_dataset.copy(name="test-fov")
     dataset = fov_bkg_maker.run(test_dataset)
 
     assert_allclose(dataset.background_model.norm.value, 0.83078, rtol=1e-4)
@@ -86,7 +86,7 @@ def test_fov_bkg_maker_scale(obs_dataset, exclusion_mask):
 def test_fov_bkg_maker_fit(obs_dataset, exclusion_mask):
     fov_bkg_maker = FoVBackgroundMaker(method="fit", exclusion_mask=exclusion_mask)
 
-    test_dataset = obs_dataset.copy()
+    test_dataset = obs_dataset.copy(name="test-fov")
     dataset = fov_bkg_maker.run(test_dataset)
 
     assert_allclose(dataset.background_model.norm.value, 0.8307, rtol=1e-4)
@@ -98,14 +98,14 @@ def test_fov_bkg_maker_fit(obs_dataset, exclusion_mask):
 def test_fov_bkg_maker_fit_with_source_model(obs_dataset, exclusion_mask):
     fov_bkg_maker = FoVBackgroundMaker(method="fit", exclusion_mask=exclusion_mask)
 
-    test_dataset = obs_dataset.copy()
+    test_dataset = obs_dataset.copy(name="test-fov")
     spatial_model = GaussianSpatialModel(
         lon_0="0.2 deg", lat_0="0.1 deg", sigma="0.2 deg", frame="galactic"
     )
     spectral_model = PowerLawSpectralModel(
         index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
     )
-    model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model)
+    model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model, name="test-source")
     test_dataset.models.append(model)
     dataset = fov_bkg_maker.run(test_dataset)
 
@@ -123,7 +123,7 @@ def test_fov_bkg_maker_fit_with_source_model(obs_dataset, exclusion_mask):
 def test_fov_bkg_maker_fit_with_tilt(obs_dataset, exclusion_mask):
     fov_bkg_maker = FoVBackgroundMaker(method="fit", exclusion_mask=exclusion_mask)
 
-    test_dataset = obs_dataset.copy()
+    test_dataset = obs_dataset.copy(name="test-fov")
     test_dataset.background_model.tilt.frozen = False
     dataset = fov_bkg_maker.run(test_dataset)
 

gammapy/modeling/datasets.py

@@ -123,7 +123,7 @@ def parameters(self):
         Duplicate parameter objects have been removed.
         The order of the unique parameters remains.
         """
-        parameters = Parameters.from_stack(_.parameters for _ in self)
+        parameters = Parameters.from_stack([_.models.parameters for _ in self])
         return parameters.unique_parameters
 
     @property