pyelq 1.1.2__tar.gz → 1.1.4__tar.gz

{pyelq-1.1.2 → pyelq-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyelq
-Version: 1.1.2
+Version: 1.1.4
 Summary: Package for detection, localization and quantification code.
 License: Apache-2.0
 Keywords: gas dispersion,emission,detection,localization,quantification

{pyelq-1.1.2 → pyelq-1.1.4}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pyelq"
-version = "1.1.2"
+version = "1.1.4"
 description = "Package for detection, localization and quantification code."
 authors = ["Bas van de Kerkhof", "Matthew Jones", "David Randell"]
 homepage = "https://sede-open.github.io/pyELQ/"

{pyelq-1.1.2 → pyelq-1.1.4}/src/pyelq/component/source_model.py

@@ -19,7 +19,7 @@ A SourceModel instance inherits from 3 super-classes:
 from abc import abstractmethod
 from copy import deepcopy
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Tuple, Union
 
 import numpy as np
 from openmcmc import parameter
@@ -43,7 +43,50 @@ if TYPE_CHECKING:
 
 
 @dataclass
-class SourceGrouping:
+class ParameterMapping:
+    """Class for defining mapping variable/parameter labels needed for creating an analysis.
+
+    In instances where we want to include multiple source_model instances in an MCMC analysis, we can apply a suffix to
+    all of the parameter names in the mapping dictionary. This allows us to create separate variables for different
+    source map types, so that these can be associated with different sampler types in the MCMC analysis.
+
+    Attributes:
+        map (dict): dictionary containing mapping between variable types and MCMC parameters.
+
+    """
+
+    map: dict = field(
+        default_factory=lambda: {
+            "source": "s",
+            "coupling_matrix": "A",
+            "emission_rate_mean": "mu_s",
+            "emission_rate_precision": "lambda_s",
+            "allocation": "alloc_s",
+            "source_prob": "s_prob",
+            "precision_prior_shape": "a_lam_s",
+            "precision_prior_rate": "b_lam_s",
+            "source_location": "z_src",
+            "number_sources": "n_src",
+            "number_source_rate": "rho",
+        }
+    )
+
+    def append_string(self, string: str = None):
+        """Apply the supplied string as a suffix to all of the values in the mapping dictionary.
+
+        For example: {'source': 's'} would become {'source': 's_fixed'} when string = 'fixed' is passed as the argument.
+        If string is None, nothing is appended.
+
+        Args:
+            string (str): string to append to the variable names.
+
+        """
+        for key, value in self.map.items():
+            self.map[key] = value + "_" + string
+
+
+@dataclass
+class SourceGrouping(ParameterMapping):
     """Superclass for source grouping approach.
 
     Source grouping method determines the group allocation of each source in the model, e.g: slab and spike
@@ -52,13 +95,11 @@ class SourceGrouping:
     Attributes:
         nof_sources (int): number of sources in the model.
         emission_rate_mean (Union[float, np.ndarray]): prior mean parameter for the emission rate distribution.
-        _source_key (str): label for the source parameter to be used in the distributions, samplers, MCMC state etc.
 
     """
 
     nof_sources: int = field(init=False)
     emission_rate_mean: Union[float, np.ndarray] = field(init=False)
-    _source_key: str = field(init=False, default="s")
 
     @abstractmethod
     def make_allocation_model(self, model: list) -> list:
@@ -118,8 +159,14 @@ class NullGrouping(SourceGrouping):
         2) The case where the dimensionality of the source map is changing during the inversion, and a common prior
             mean and precision term are used for all sources.
 
+    Attributes:
+    number_on_sources (np.ndarray): number of sources switched on in the solution, per iteration. Extracted as a
+        property from the MCMC samples in self.from_mcmc_group().
+
     """
 
+    number_on_sources: np.ndarray = field(init=False)
+
     def make_allocation_model(self, model: list) -> list:
         """Initialise the source allocation part of the model.
 
@@ -163,20 +210,19 @@ class NullGrouping(SourceGrouping):
             dict: state updated with parameters related to the source grouping.
 
         """
-        state["mu_s"] = np.array(self.emission_rate_mean, ndmin=1)
-        state["alloc_s"] = np.zeros((self.nof_sources, 1), dtype="int")
+        state[self.map["emission_rate_mean"]] = np.array(self.emission_rate_mean, ndmin=1)
+        state[self.map["allocation"]] = np.zeros((self.nof_sources, 1), dtype="int")
         return state
 
     def from_mcmc_group(self, store: dict):
         """Extract posterior allocation samples from the MCMC sampler, attach them to the class.
 
-        We have not implemented anything here as there is nothing to fetch from the MCMC solution here for the
-        NullGrouping Class.
+        Gets the number of sources present in each iteration of the MCMC sampler, and attaches this as a class property.
 
         Args:
             store (dict): dictionary containing samples from the MCMC.
-
         """
+        self.number_on_sources = np.count_nonzero(np.logical_not(np.isnan(store[self.map["source"]])), axis=0)
 
 
 @dataclass
@@ -190,11 +236,13 @@ class SlabAndSpike(SourceGrouping):
         slab_probability (float): prior probability of allocation to the slab component. Defaults to 0.05.
         allocation (np.ndarray): set of allocation samples, with shape=(n_sources, n_iterations). Attached to
             the class by self.from_mcmc_group().
+        number_on_sources (np.ndarray): number of sources switched on in the solution, per iteration.
 
     """
 
     slab_probability: float = 0.05
     allocation: np.ndarray = field(init=False)
+    number_on_sources: np.ndarray = field(init=False)
 
     def make_allocation_model(self, model: list) -> list:
         """Initialise the source allocation part of the model.
@@ -206,7 +254,7 @@ class SlabAndSpike(SourceGrouping):
             list: overall model list, updated with allocation distribution.
 
         """
-        model.append(Categorical("alloc_s", prob="s_prob"))
+        model.append(Categorical(self.map["allocation"], prob=self.map["source_prob"]))
         return model
 
     def make_allocation_sampler(self, model: Model, sampler_list: list) -> list:
@@ -220,7 +268,9 @@ class SlabAndSpike(SourceGrouping):
             list: sampler_list updated with sampler for the source allocation.
 
         """
-        sampler_list.append(MixtureAllocation(param="alloc_s", model=model, response_param=self._source_key))
+        sampler_list.append(
+            MixtureAllocation(param=self.map["allocation"], model=model, response_param=self.map["source"])
+        )
         return sampler_list
 
     def make_allocation_state(self, state: dict) -> dict:
@@ -233,9 +283,11 @@ class SlabAndSpike(SourceGrouping):
             dict: state updated with parameters related to the source grouping.
 
         """
-        state["mu_s"] = np.array(self.emission_rate_mean, ndmin=1)
-        state["s_prob"] = np.tile(np.array([self.slab_probability, 1 - self.slab_probability]), (self.nof_sources, 1))
-        state["alloc_s"] = np.ones((self.nof_sources, 1), dtype="int")
+        state[self.map["emission_rate_mean"]] = np.array(self.emission_rate_mean, ndmin=1)
+        state[self.map["source_prob"]] = np.tile(
+            np.array([self.slab_probability, 1 - self.slab_probability]), (self.nof_sources, 1)
+        )
+        state[self.map["allocation"]] = np.ones((self.nof_sources, 1), dtype="int")
         return state
 
     def from_mcmc_group(self, store: dict):
@@ -245,11 +297,12 @@ class SlabAndSpike(SourceGrouping):
             store (dict): dictionary containing samples from the MCMC.
 
         """
-        self.allocation = store["alloc_s"]
+        self.allocation = store[self.map["allocation"]]
+        self.number_on_sources = self.allocation.shape[0] - np.sum(self.allocation, axis=0)
 
 
 @dataclass
-class SourceDistribution:
+class SourceDistribution(ParameterMapping):
     """Superclass for source emission rate distribution.
 
     Source distribution determines the type of prior to be used for the source emission rates, and the transformation
@@ -349,9 +402,13 @@ class NormalResponse(SourceDistribution):
 
         model.append(
             mcmcNormal(
-                "s",
-                mean=parameter.MixtureParameterVector(param="mu_s", allocation="alloc_s"),
-                precision=parameter.MixtureParameterMatrix(param="lambda_s", allocation="alloc_s"),
+                self.map["source"],
+                mean=parameter.MixtureParameterVector(
+                    param=self.map["emission_rate_mean"], allocation=self.map["allocation"]
+                ),
+                precision=parameter.MixtureParameterMatrix(
+                    param=self.map["emission_rate_precision"], allocation=self.map["allocation"]
+                ),
                 domain_response_lower=domain_response_lower,
             )
         )
@@ -370,7 +427,7 @@ class NormalResponse(SourceDistribution):
         """
         if sampler_list is None:
             sampler_list = []
-        sampler_list.append(NormalNormal("s", model))
+        sampler_list.append(NormalNormal(self.map["source"], model))
         return sampler_list
 
     def make_source_state(self, state: dict) -> dict:
@@ -383,7 +440,7 @@ class NormalResponse(SourceDistribution):
             dict: state updated with initial emission rate vector.
 
         """
-        state["s"] = np.zeros((self.nof_sources, 1))
+        state[self.map["source"]] = np.zeros((self.nof_sources, 1))
         return state
 
     def from_mcmc_dist(self, store: dict):
@@ -393,7 +450,7 @@ class NormalResponse(SourceDistribution):
             store (dict): dictionary containing samples from the MCMC.
 
         """
-        self.emission_rate = store["s"]
+        self.emission_rate = store[self.map["source"]]
 
 
 @dataclass
@@ -447,12 +504,19 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
         initial_precision (Union[float, np.ndarray]): initial value for the source emission rate precision parameter.
         precision_scalar (np.ndarray): precision values generated by MCMC inversion.
 
+        all_source_locations (ENU): ENU object containing the locations of after the mcmc has been run, therefore in
+            the situation where the reversible_jump == True, this will be the final locations of the sources in the
+            solution over all iterations. For the case where reversible_jump == False, this will be the locations of
+            the sources in the source map and will not change during the course of the inversion.
+        individual_source_labels (list, optional): list of labels for each source in the source map, defaults to None.
+
         coverage_detection (float): sensor detection threshold (in ppm) to be used for coverage calculations.
         coverage_test_source (float): test source (in kg/hr) which we wish to be able to see in coverage calculation.
 
         threshold_function (Callable): Callable function which returns a single value that defines the threshold
             for the coupling in a lambda function form. Examples: lambda x: np.quantile(x, 0.95, axis=0),
             lambda x: np.max(x, axis=0), lambda x: np.mean(x, axis=0). Defaults to np.quantile.
+        label_string (str): string to append to the parameter mapping, e.g. for fixed sources, defaults to None.
 
     """
 
@@ -476,11 +540,26 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
     initial_precision: Union[float, np.ndarray] = 1.0
     precision_scalar: np.ndarray = field(init=False)
 
+    all_source_locations: np.ndarray = field(init=False)
+    individual_source_labels: Optional[list] = None
+
     coverage_detection: float = 0.1
     coverage_test_source: float = 6.0
 
     threshold_function: callable = lambda x: np.quantile(x, 0.95, axis=0)
 
+    label_string: Optional[str] = None
+
+    def __post_init__(self):
+        """Post-initialisation of the class.
+
+        This function is called after the class has been initialised,
+        and is used to set up the mapping dictionary for the class by applying the
+        append_string function to the mapping dictionary.
+        """
+        if self.label_string is not None:
+            self.append_string(self.label_string)
+
     @property
     def nof_sources(self):
         """Get number of sources in the source map."""
@@ -583,15 +662,17 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
             state (dict): state dictionary containing updated coupling information.
 
         """
-        self.dispersion_model.source_map.location.from_array(state["z_src"][:, [update_column]].T)
+        self.dispersion_model.source_map.location.from_array(state[self.map["source_location"]][:, [update_column]].T)
         new_coupling = self.dispersion_model.compute_coupling(
             self.sensor_object, self.meteorology, self.gas_species, output_stacked=True, run_interpolation=False
         )
 
-        if update_column == state["A"].shape[1]:
-            state["A"] = np.concatenate((state["A"], new_coupling), axis=1)
-        elif update_column < state["A"].shape[1]:
-            state["A"][:, [update_column]] = new_coupling
+        if update_column == state[self.map["coupling_matrix"]].shape[1]:
+            state[self.map["coupling_matrix"]] = np.concatenate(
+                (state[self.map["coupling_matrix"]], new_coupling), axis=1
+            )
+        elif update_column < state[self.map["coupling_matrix"]].shape[1]:
+            state[self.map["coupling_matrix"]][:, [update_column]] = new_coupling
         else:
             raise ValueError("Invalid column specification for updating.")
         return state
@@ -629,10 +710,12 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
                 (i.e. log[p(current | proposed)])
 
         """
-        prop_state = self.update_coupling_column(prop_state, int(prop_state["n_src"]) - 1)
-        prop_state["alloc_s"] = np.concatenate((prop_state["alloc_s"], np.array([0], ndmin=2)), axis=0)
+        prop_state = self.update_coupling_column(prop_state, int(prop_state[self.map["number_sources"]]) - 1)
+        prop_state[self.map["allocation"]] = np.concatenate(
+            (prop_state[self.map["allocation"]], np.array([0], ndmin=2)), axis=0
+        )
         in_cov_area = self.dispersion_model.compute_coverage(
-            prop_state["A"][:, -1],
+            prop_state[self.map["coupling_matrix"]][:, -1],
             coverage_threshold=self.coverage_threshold,
             threshold_function=self.threshold_function,
         )
@@ -644,8 +727,7 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
 
         return prop_state, logp_pr_g_cr, logp_cr_g_pr
 
-    @staticmethod
-    def death_function(current_state: dict, prop_state: dict, deletion_index: int) -> Tuple[dict, float, float]:
+    def death_function(self, current_state: dict, prop_state: dict, deletion_index: int) -> Tuple[dict, float, float]:
         """Update MCMC state based on source death proposal.
 
         Proposed state updated as follows:
@@ -669,8 +751,10 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
                 (i.e. log[p(current | proposed)])
 
         """
-        prop_state["A"] = np.delete(prop_state["A"], obj=deletion_index, axis=1)
-        prop_state["alloc_s"] = np.delete(prop_state["alloc_s"], obj=deletion_index, axis=0)
+        prop_state[self.map["coupling_matrix"]] = np.delete(
+            prop_state[self.map["coupling_matrix"]], obj=deletion_index, axis=1
+        )
+        prop_state[self.map["allocation"]] = np.delete(prop_state[self.map["allocation"]], obj=deletion_index, axis=0)
         logp_pr_g_cr = 0.0
         logp_cr_g_pr = 0.0
 
@@ -693,7 +777,7 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
         prop_state = deepcopy(current_state)
         prop_state = self.update_coupling_column(prop_state, update_column)
         in_cov_area = self.dispersion_model.compute_coverage(
-            prop_state["A"][:, update_column],
+            prop_state[self.map["coupling_matrix"]][:, update_column],
             coverage_threshold=self.coverage_threshold,
             threshold_function=self.threshold_function,
         )
@@ -714,16 +798,22 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
         model = self.make_allocation_model(model)
         model = self.make_source_model(model)
         if self.update_precision:
-            model.append(Gamma("lambda_s", shape="a_lam_s", rate="b_lam_s"))
+            model.append(
+                Gamma(
+                    self.map["emission_rate_precision"],
+                    shape=self.map["precision_prior_shape"],
+                    rate=self.map["precision_prior_rate"],
+                )
+            )
         if self.reversible_jump:
             model.append(
                 Uniform(
-                    response="z_src",
+                    response=self.map["source_location"],
                     domain_response_lower=self.site_limits[:, [0]],
                     domain_response_upper=self.site_limits[:, [1]],
                 )
             )
-            model.append(Poisson(response="n_src", rate="rho"))
+            model.append(Poisson(response=self.map["number_sources"], rate=self.map["number_source_rate"]))
         return model
 
     def make_sampler(self, model: Model, sampler_list: list) -> list:
@@ -740,7 +830,7 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
         sampler_list = self.make_source_sampler(model, sampler_list)
         sampler_list = self.make_allocation_sampler(model, sampler_list)
         if self.update_precision:
-            sampler_list.append(NormalGamma("lambda_s", model))
+            sampler_list.append(NormalGamma(self.map["emission_rate_precision"], model))
         if self.reversible_jump:
             sampler_list = self.make_sampler_rjmcmc(model, sampler_list)
         return sampler_list
@@ -757,15 +847,15 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
         """
         state = self.make_allocation_state(state)
         state = self.make_source_state(state)
-        state["A"] = self.coupling
-        state["lambda_s"] = np.array(self.initial_precision, ndmin=1)
+        state[self.map["coupling_matrix"]] = self.coupling
+        state[self.map["emission_rate_precision"]] = np.array(self.initial_precision, ndmin=1)
         if self.update_precision:
-            state["a_lam_s"] = np.ones_like(self.initial_precision) * self.prior_precision_shape
-            state["b_lam_s"] = np.ones_like(self.initial_precision) * self.prior_precision_rate
+            state[self.map["precision_prior_shape"]] = np.ones_like(self.initial_precision) * self.prior_precision_shape
+            state[self.map["precision_prior_rate"]] = np.ones_like(self.initial_precision) * self.prior_precision_rate
         if self.reversible_jump:
-            state["z_src"] = self.dispersion_model.source_map.location.to_array().T
-            state["n_src"] = state["z_src"].shape[1]
-            state["rho"] = self.rate_num_sources
+            state[self.map["source_location"]] = self.dispersion_model.source_map.location.to_array().T
+            state[self.map["number_sources"]] = state[self.map["source_location"]].shape[1]
+            state[self.map["number_source_rate"]] = self.rate_num_sources
         return state
 
     def make_sampler_rjmcmc(self, model: Model, sampler_list: list) -> list:
@@ -785,11 +875,13 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
             sampler_list (list): list of samplers updated with samplers corresponding to RJMCMC routine.
 
         """
-        sampler_list[-1].max_variable_size = self.n_sources_max
+        for sampler in sampler_list:
+            if sampler.param == self.map["source"]:
+                sampler.max_variable_size = self.n_sources_max
 
         sampler_list.append(
             RandomWalkLoop(
-                "z_src",
+                self.map["source_location"],
                 model,
                 step=self.random_walk_step_size,
                 max_variable_size=(3, self.n_sources_max),
@@ -797,13 +889,18 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
                 state_update_function=self.move_function,
             )
         )
-        matching_params = {"variable": "s", "matrix": "A", "scale": 1.0, "limits": [0.0, 1e6]}
+        matching_params = {
+            "variable": self.map["source"],
+            "matrix": self.map["coupling_matrix"],
+            "scale": 1.0,
+            "limits": [0.0, 1e6],
+        }
         sampler_list.append(
             ReversibleJump(
-                "n_src",
+                self.map["number_sources"],
                 model,
                 step=np.array([1.0], ndmin=2),
-                associated_params="z_src",
+                associated_params=self.map["source_location"],
                 n_max=self.n_sources_max,
                 state_birth_function=self.birth_function,
                 state_death_function=self.death_function,
@@ -815,14 +912,41 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
     def from_mcmc(self, store: dict):
         """Extract results of mcmc from mcmc.store and attach to components.
 
+        For the reversible jump case we extract all estimated source locations
+        per iteration. For the fixed sources case we grab the source locations
+        from the inputted sourcemap and repeat those for all iterations.
+
         Args:
             store (dict): mcmc result dictionary.
 
         """
         self.from_mcmc_group(store)
         self.from_mcmc_dist(store)
+        if self.individual_source_labels is None:
+            self.individual_source_labels = list(np.repeat(None, store[self.map["source"]].shape[0]))
+
         if self.update_precision:
-            self.precision_scalar = store["lambda_s"]
+            self.precision_scalar = store[self.map["emission_rate_precision"]]
+
+        if self.reversible_jump:
+            reference_latitude = self.dispersion_model.source_map.location.ref_latitude
+            reference_longitude = self.dispersion_model.source_map.location.ref_longitude
+            ref_altitude = self.dispersion_model.source_map.location.ref_altitude
+            self.all_source_locations = ENU(
+                ref_latitude=reference_latitude,
+                ref_longitude=reference_longitude,
+                ref_altitude=ref_altitude,
+                east=store[self.map["source_location"]][0, :, :],
+                north=store[self.map["source_location"]][1, :, :],
+                up=store[self.map["source_location"]][2, :, :],
+            )
+
+        else:
+            location_temp = self.dispersion_model.source_map.location.to_enu()
+            location_temp.east = np.repeat(location_temp.east[:, np.newaxis], store["log_post"].shape[0], axis=1)
+            location_temp.north = np.repeat(location_temp.north[:, np.newaxis], store["log_post"].shape[0], axis=1)
+            location_temp.up = np.repeat(location_temp.up[:, np.newaxis], store["log_post"].shape[0], axis=1)
+            self.all_source_locations = location_temp
 
     def plot_iterations(self, plot: "Plot", burn_in_value: int, y_axis_type: str = "linear") -> "Plot":
         """Plot the emission rate estimates source model object against MCMC iteration.

{pyelq-1.1.2 → pyelq-1.1.4}/src/pyelq/model.py

@@ -9,6 +9,7 @@ This module provides a class definition for the main functionalities of the code
 openMCMC repo and defining some plotting wrappers.
 
 """
+import re
 import warnings
 from dataclasses import dataclass, field
 from typing import Union
@@ -23,6 +24,7 @@ from pyelq.component.background import Background, SpatioTemporalBackground
 from pyelq.component.error_model import BySensor, ErrorModel
 from pyelq.component.offset import PerSensor
 from pyelq.component.source_model import Normal, SourceModel
+from pyelq.coordinate_system import ENU
 from pyelq.gas_species import GasSpecies
 from pyelq.meteorology import Meteorology, MeteorologyGroup
 from pyelq.plotting.plot import Plot
@@ -62,7 +64,7 @@ class ELQModel:
         meteorology: Union[Meteorology, MeteorologyGroup],
         gas_species: GasSpecies,
         background: Background = SpatioTemporalBackground(),
-        source_model: SourceModel = Normal(),
+        source_model: Union[list, SourceModel] = Normal(),
         error_model: ErrorModel = BySensor(),
         offset_model: PerSensor = None,
     ):
@@ -82,7 +84,9 @@ class ELQModel:
             meteorology (Union[Meteorology, MeteorologyGroup]): meteorology data.
             gas_species (GasSpecies): gas species object.
             background (Background): background model specification. Defaults to SpatioTemporalBackground().
-            source_model (SourceModel): source model specification. Defaults to Normal().
+            source_model (Union[list, SourceModel]): source model specification. This can be a list of multiple
+            SourceModels or a single SourceModel. Defaults to Normal(). If a single SourceModel is used, it will
+            be converted to a list.
             error_model (Precision): measurement precision model specification. Defaults to BySensor().
             offset_model (PerSensor): offset model specification. Defaults to None.
 
@@ -92,10 +96,19 @@ class ELQModel:
         self.gas_species = gas_species
         self.components = {
             "background": background,
-            "source": source_model,
             "error_model": error_model,
             "offset": offset_model,
         }
+
+        if source_model is not None:
+            if not isinstance(source_model, list):
+                source_model = [source_model]
+            for source in source_model:
+                if source.label_string is None:
+                    self.components["source"] = source
+                else:
+                    self.components["source_" + source.label_string] = source
+
         if error_model is None:
             self.components["error_model"] = BySensor()
             warnings.warn("None is not an allowed type for error_model: resetting to default BySensor model.")
@@ -107,17 +120,19 @@ class ELQModel:
         """Take data inputs and extract relevant properties."""
         self.form = {}
         self.transform = {}
-        component_keys = list(self.components.keys())
-        if "background" in component_keys:
-            self.form["bg"] = "B_bg"
-            self.transform["bg"] = False
-        if "source" in component_keys:
-            self.transform["s"] = False
-            self.form["s"] = "A"
-        if "offset" in component_keys:
-            self.form["d"] = "B_d"
-            self.transform["d"] = False
-        for key in component_keys:
+        for key, component in self.components.items():
+
+            if "background" in key:
+                self.form["bg"] = "B_bg"
+                self.transform["bg"] = False
+            if re.match("source", key):
+                source_component_map = component.map
+                self.transform[source_component_map["source"]] = False
+                self.form[source_component_map["source"]] = source_component_map["coupling_matrix"]
+            if "offset" in key:
+                self.form["d"] = "B_d"
+                self.transform["d"] = False
+
             self.components[key].initialise(self.sensor_object, self.meteorology, self.gas_species)
 
     def to_mcmc(self):
@@ -175,6 +190,109 @@ class ELQModel:
         for key in self.mcmc.store:
             state[key] = self.mcmc.store[key]
 
+        self.make_combined_source_model()
+
+    def make_combined_source_model(self):
+        """Aggregate multiple individual source models into a single combined source model.
+
+        This function iterates through the existing source models stored in `self.components` and consolidates them
+        into a unified source model named `"sources_combined"`. This is particularly useful when multiple source
+        models are involved in an analysis, and a merged representation is required for visualization.
+
+        The combined source model is created as an instance of the `Normal` model, with the label string
+        "sources_combined" with the following attributes:
+        - emission_rate: concatenated across all source models.
+        - all_source_locations: concatenated across all source models.
+        - number_on_sources: derived by summing the individual source counts across all source models
+        - label_string: concatenated across all source models.
+        - individual_source_labels: concatenated across all source models.
+
+        Once combined, the `"sources_combined"` model is stored in the `self.components` dictionary for later use.
+
+        Raises:
+            ValueError: If the reference locations of the individual source models are inconsistent.
+            This is checked by comparing the reference latitude, longitude, and altitude of each source model.
+
+        """
+        combined_model = Normal(label_string="sources_combined")
+        emission_rate = np.empty((0, self.mcmc.n_iter))
+        all_source_locations_east = np.empty((0, self.mcmc.n_iter))
+        all_source_locations_north = np.empty((0, self.mcmc.n_iter))
+        all_source_locations_up = np.empty((0, self.mcmc.n_iter))
+        number_on_sources = np.empty((0, self.mcmc.n_iter))
+        label_string = []
+        individual_source_labels = []
+
+        ref_latitude = None
+        ref_longitude = None
+        ref_altitude = None
+        for key, component in self.components.items():
+            if re.match("source", key):
+                comp_ref_latitude = component.all_source_locations.ref_latitude
+                comp_ref_longitude = component.all_source_locations.ref_longitude
+                comp_ref_altitude = component.all_source_locations.ref_altitude
+                if ref_latitude is None and ref_longitude is None and ref_altitude is None:
+                    ref_latitude = comp_ref_latitude
+                    ref_longitude = comp_ref_longitude
+                    ref_altitude = comp_ref_altitude
+                else:
+                    if (
+                        not np.isclose(ref_latitude, comp_ref_latitude)
+                        or not np.isclose(ref_longitude, comp_ref_longitude)
+                        or not np.isclose(ref_altitude, comp_ref_altitude)
+                    ):
+                        raise ValueError(
+                            f"Inconsistent reference locations in component '{key}'. "
+                            "All source models must share the same reference location."
+                        )
+                emission_rate = np.concatenate((emission_rate, component.emission_rate))
+                number_on_sources = np.concatenate(
+                    (
+                        number_on_sources.reshape((-1, self.mcmc.n_iter)),
+                        component.number_on_sources.reshape(-1, self.mcmc.n_iter),
+                    ),
+                    axis=0,
+                )
+                label_string.append(component.label_string)
+                individual_source_labels.append(component.individual_source_labels)
+
+                all_source_locations_east = np.concatenate(
+                    (
+                        all_source_locations_east,
+                        component.all_source_locations.east.reshape((-1, self.mcmc.n_iter)),
+                    ),
+                    axis=0,
+                )
+                all_source_locations_north = np.concatenate(
+                    (
+                        all_source_locations_north,
+                        component.all_source_locations.north.reshape((-1, self.mcmc.n_iter)),
+                    ),
+                    axis=0,
+                )
+                all_source_locations_up = np.concatenate(
+                    (
+                        all_source_locations_up,
+                        component.all_source_locations.up.reshape((-1, self.mcmc.n_iter)),
+                    ),
+                    axis=0,
+                )
+
+        combined_model.all_source_locations = ENU(
+            ref_altitude=ref_altitude,
+            ref_latitude=ref_latitude,
+            ref_longitude=ref_longitude,
+            east=all_source_locations_east,
+            north=all_source_locations_north,
+            up=all_source_locations_up,
+        )
+
+        combined_model.emission_rate = emission_rate
+        combined_model.label_string = label_string
+        combined_model.number_on_sources = np.sum(number_on_sources, axis=0)
+        combined_model.individual_source_labels = [item for sublist in individual_source_labels for item in sublist]
+        self.components["sources_combined"] = combined_model
+
     def plot_log_posterior(self, burn_in_value: int, plot: Plot = Plot()) -> Plot():
         """Plots the trace of the log posterior over the iterations of the MCMC.
 

{pyelq-1.1.2 → pyelq-1.1.4}/src/pyelq/plotting/plot.py

@@ -9,6 +9,7 @@ Large module containing all the plotting code used to create various plots. Cont
 definition.
 
 """
+import re
 import warnings
 from copy import deepcopy
 from dataclasses import dataclass, field
@@ -16,6 +17,7 @@ from typing import TYPE_CHECKING, Any, Callable, Type, Union
 
 import numpy as np
 import pandas as pd
+import plotly.express as px
 import plotly.figure_factory as ff
 import plotly.graph_objects as go
 from geojson import Feature, FeatureCollection
@@ -167,14 +169,7 @@ def create_trace_specifics(object_to_plot: Union[Type[SlabAndSpike], SourceModel
         title_text = "Number of Sources 'on' against MCMC iterations"
         x_label = MCMC_ITERATION_NUMBER_LITERAL
         y_label = "Number of Sources 'on'"
-        emission_rates = object_to_plot.emission_rate
-        if isinstance(object_to_plot, SlabAndSpike):
-            total_nof_sources = emission_rates.shape[0]
-            y_values = total_nof_sources - np.sum(object_to_plot.allocation, axis=0)
-        elif object_to_plot.reversible_jump:
-            y_values = np.count_nonzero(np.logical_not(np.isnan(emission_rates)), axis=0)
-        else:
-            raise TypeError("No plotting routine implemented for this SourceModel type.")
+        y_values = object_to_plot.number_on_sources
         x_values = np.array(range(y_values.size))
         color = "rgb(248, 156, 116)"
         name = "Number of Sources 'on'"
@@ -836,13 +831,17 @@ class Plot:
 
         for source_idx in range(source_model_object.emission_rate.shape[0]):
             y_values = source_model_object.emission_rate[source_idx, :]
+            if source_model_object.individual_source_labels[source_idx] is not None:
+                source_label = source_model_object.individual_source_labels[source_idx]
+            else:
+                source_label = f"Source {source_idx}"
 
             fig = plot_single_scatter(
                 fig=fig,
                 x_values=x_values,
                 y_values=y_values,
                 color=RGB_LIGHT_BLUE,
-                name=f"Source {source_idx}",
+                name=source_label,
                 burn_in=burn_in,
                 show_legend=False,
                 legend_group="Source traces",
@@ -973,20 +972,24 @@ class Plot:
     def plot_quantification_results_on_map(
         self,
         model_object: "ELQModel",
+        source_model_to_plot_key: str = None,
         bin_size_x: float = 1,
         bin_size_y: float = 1,
         normalized_count_limit: float = 0.005,
         burn_in: int = 0,
         show_summary_results: bool = True,
+        show_fixed_source_locations: bool = True,
     ):
         """Function to create a map with the quantification results of the model object.
 
-        This function takes the ELQModel object and calculates the statistics for the quantification results. It then
-        populates the figure dictionary with three different maps showing the normalized count, median emission rate
-        and the inter-quartile range of the emission rate estimates.
+        This function takes the "SourceModel" object and calculates the statistics for the quantification results.
+        It then populates the figure dictionary with three different maps showing the normalized count,
+        median emission rate and the inter-quartile range of the emission rate estimates.
 
         Args:
             model_object (ELQModel): ELQModel object containing the quantification results
+            source_model_to_plot_key (str, optional): Key to use in the model_object.components dictionary to access
+              the SourceModel object. If None, defaults to "sources_combined".
             bin_size_x (float, optional): Size of the bins in the x-direction. Defaults to 1.
             bin_size_y (float, optional): Size of the bins in the y-direction. Defaults to 1.
             normalized_count_limit (float, optional): Limit for the normalized count to show on the map.
@@ -994,18 +997,30 @@ class Plot:
             burn_in (int, optional): Number of burn-in iterations to discard before calculating the statistics.
                 Defaults to 0.
             show_summary_results (bool, optional): Flag to show the summary results on the map. Defaults to True.
+            show_fixed_source_locations (bool, optional): Flag to show the fixed sources location when present in one
+                of the sourcemaps. Defaults to True.
 
         """
-        ref_latitude = model_object.components["source"].dispersion_model.source_map.location.ref_latitude
-        ref_longitude = model_object.components["source"].dispersion_model.source_map.location.ref_longitude
-        ref_altitude = model_object.components["source"].dispersion_model.source_map.location.ref_altitude
+        if source_model_to_plot_key is None:
+            source_model_to_plot_key = "sources_combined"
+
+        source_model = model_object.components[source_model_to_plot_key]
+        sensor_object = model_object.sensor_object
+
+        source_locations = source_model.all_source_locations
+        emission_rates = source_model.emission_rate
 
-        datetime_min_string = model_object.sensor_object.time.min().strftime("%d-%b-%Y, %H:%M:%S")
-        datetime_max_string = model_object.sensor_object.time.max().strftime("%d-%b-%Y, %H:%M:%S")
+        ref_latitude = source_locations.ref_latitude
+        ref_longitude = source_locations.ref_longitude
+        ref_altitude = source_locations.ref_altitude
+
+        datetime_min_string = sensor_object.time.min().strftime("%d-%b-%Y, %H:%M:%S")
+        datetime_max_string = sensor_object.time.max().strftime("%d-%b-%Y, %H:%M:%S")
 
         result_weighted, _, normalized_count, count_boolean, enu_points, summary_result = (
             calculate_rectangular_statistics(
-                model_object=model_object,
+                emission_rates=emission_rates,
+                source_locations=source_locations,
                 bin_size_x=bin_size_x,
                 bin_size_y=bin_size_y,
                 burn_in=burn_in,
@@ -1043,7 +1058,7 @@ class Plot:
             font_family="Futura",
             font_size=15,
         )
-        model_object.sensor_object.plot_sensor_location(self.figure_dict["count_map"])
+        sensor_object.plot_sensor_location(self.figure_dict["count_map"])
         self.figure_dict["count_map"].update_traces(showlegend=False)
 
         adjusted_result_weights = result_weighted.copy()
@@ -1069,7 +1084,7 @@ class Plot:
             font_family="Futura",
             font_size=15,
         )
-        model_object.sensor_object.plot_sensor_location(self.figure_dict["median_map"])
+        sensor_object.plot_sensor_location(self.figure_dict["median_map"])
         self.figure_dict["median_map"].update_traces(showlegend=False)
 
         iqr_of_all_emissions = np.nanquantile(a=adjusted_result_weights, q=0.75, axis=2) - np.nanquantile(
@@ -1094,9 +1109,28 @@ class Plot:
             font_family="Futura",
             font_size=15,
         )
-        model_object.sensor_object.plot_sensor_location(self.figure_dict["iqr_map"])
+        sensor_object.plot_sensor_location(self.figure_dict["iqr_map"])
         self.figure_dict["iqr_map"].update_traces(showlegend=False)
 
+        if show_fixed_source_locations:
+            for key, _ in model_object.components.items():
+                if bool(re.search("fixed", key)):
+                    source_model_fixed = model_object.components[key]
+                    source_locations_fixed = source_model_fixed.all_source_locations
+                    source_location_fixed_lla = source_locations_fixed.to_lla()
+                    sources_lat = source_location_fixed_lla.latitude[:, 0]
+                    sources_lon = source_location_fixed_lla.longitude[:, 0]
+                    fixed_source_location_trace = go.Scattermap(
+                        mode="markers",
+                        lon=sources_lon,
+                        lat=sources_lat,
+                        name=f"Fixed source locations, {key}",
+                        marker={"size": 10, "opacity": 0.8},
+                    )
+                    self.figure_dict["count_map"].add_trace(fixed_source_location_trace)
+                    self.figure_dict["median_map"].add_trace(fixed_source_location_trace)
+                    self.figure_dict["iqr_map"].add_trace(fixed_source_location_trace)
+
         if show_summary_results:
             self.figure_dict["count_map"].add_trace(summary_trace)
             self.figure_dict["count_map"].update_traces(showlegend=True)

{pyelq-1.1.2 → pyelq-1.1.4}/src/pyelq/support_functions/post_processing.py

@@ -52,7 +52,8 @@ def is_regularly_spaced(array: np.ndarray, tolerance: float = 0.01, return_delta
 
 
 def calculate_rectangular_statistics(
-    model_object: "ELQModel",
+    emission_rates: np.ndarray,
+    source_locations: ENU,
     bin_size_x: float = 1,
     bin_size_y: float = 1,
     burn_in: int = 0,
@@ -70,7 +71,10 @@ def calculate_rectangular_statistics(
     likelihood of the blob.
 
     Args:
-        model_object (ELQModel): ELQModel object containing the results of the MCMC run.
+        emission_rates (np.ndarray): and array of shape (number_of_sources, number_of_iterations)
+        containing emission rate estimates from the MCMC run.
+        source_locations (ENU): An object containing the east, north, and up coordinates of source locations,
+        as well as reference latitude, longitude, and altitude.
         bin_size_x (float, optional): Size of the bins in the x-direction. Defaults to 1.
         bin_size_y  (float, optional): Size of the bins in the y-direction. Defaults to 1.
         burn_in (int, optional): Number of burn-in iterations used in the MCMC. Defaults to 0.
@@ -85,24 +89,9 @@ def calculate_rectangular_statistics(
         summary_result (pd.DataFrame): Summary statistics for each blob of estimates.
 
     """
-    nof_iterations = model_object.n_iter
-    ref_latitude = model_object.components["source"].dispersion_model.source_map.location.ref_latitude
-    ref_longitude = model_object.components["source"].dispersion_model.source_map.location.ref_longitude
-    ref_altitude = model_object.components["source"].dispersion_model.source_map.location.ref_altitude
-
-    if model_object.components["source"].reversible_jump:
-        all_source_locations = model_object.mcmc.store["z_src"]
-    else:
-        source_locations = (
-            model_object.components["source"]
-            .dispersion_model.source_map.location.to_enu(
-                ref_longitude=ref_longitude, ref_latitude=ref_latitude, ref_altitude=ref_altitude
-            )
-            .to_array()
-        )
-        all_source_locations = np.repeat(source_locations.T[:, :, np.newaxis], model_object.mcmc.n_iter, axis=2)
+    nof_iterations = emission_rates.shape[1]
 
-    if np.all(np.isnan(all_source_locations[:2, :, :])):
+    if np.all(np.isnan(source_locations.east)):
         warnings.warn("No sources found")
         result_weighted = np.array([[[np.nan]]])
         overall_count = np.array([[0]])
@@ -113,10 +102,10 @@ def calculate_rectangular_statistics(
 
         return result_weighted, overall_count, normalized_count, count_boolean, edges_result[:2], summary_result
 
-    min_x = np.nanmin(all_source_locations[0, :, :])
-    max_x = np.nanmax(all_source_locations[0, :, :])
-    min_y = np.nanmin(all_source_locations[1, :, :])
-    max_y = np.nanmax(all_source_locations[1, :, :])
+    min_x = np.nanmin(source_locations.east)
+    max_x = np.nanmax(source_locations.east)
+    min_y = np.nanmin(source_locations.north)
+    max_y = np.nanmax(source_locations.north)
 
     bin_min_x = np.floor(min_x - 0.1)
     bin_max_x = np.ceil(max_x + 0.1)
@@ -125,19 +114,20 @@ def calculate_rectangular_statistics(
     bin_min_iteration = burn_in + 0.5
     bin_max_iteration = nof_iterations + 0.5
 
-    max_nof_sources = all_source_locations.shape[1]
+    max_nof_sources = source_locations.east.shape[0]
 
     x_edges = np.arange(start=bin_min_x, stop=bin_max_x + bin_size_x, step=bin_size_x)
     y_edges = np.arange(start=bin_min_y, stop=bin_max_y + bin_size_y, step=bin_size_y)
     iteration_edges = np.arange(start=bin_min_iteration, stop=bin_max_iteration + bin_size_y, step=1)
 
-    result_x_vals = all_source_locations[0, :, :].flatten()
-    result_y_vals = all_source_locations[1, :, :].flatten()
-    result_z_vals = all_source_locations[2, :, :].flatten()
+    result_x_vals = source_locations.east.flatten()
+    result_y_vals = source_locations.north.flatten()
+    result_z_vals = source_locations.up.flatten()
 
     result_iteration_vals = np.array(range(nof_iterations)).reshape(1, -1) + 1
     result_iteration_vals = np.tile(result_iteration_vals, (max_nof_sources, 1)).flatten()
-    results_estimates = model_object.mcmc.store["s"].flatten()
+
+    results_estimates = emission_rates.flatten()
 
     result_weighted, _ = np.histogramdd(
         sample=np.array([result_x_vals, result_y_vals, result_iteration_vals]).T,
@@ -167,11 +157,10 @@ def calculate_rectangular_statistics(
         x_edges=x_edges,
         y_edges=y_edges,
         nof_iterations=nof_iterations,
-        ref_latitude=ref_latitude,
-        ref_longitude=ref_longitude,
-        ref_altitude=ref_altitude,
+        ref_latitude=source_locations.ref_latitude,
+        ref_longitude=source_locations.ref_longitude,
+        ref_altitude=source_locations.ref_altitude,
     )
-
     return result_weighted, overall_count, normalized_count, count_boolean, edges_result[:2], summary_result