pyelq 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

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/dlm.py

@@ -119,20 +119,22 @@ class DLM:
         mean_state_noise = np.zeros(self.nof_state_parameters)
         mean_observation_noise = np.zeros(self.nof_observables)
 
+        random_generator = np.random.default_rng(seed=None)
+
         for i in range(nof_timesteps):
             if i == 0:
                 state[:, [i]] = (
                     self.g_matrix @ init_state
-                    + np.random.multivariate_normal(mean_state_noise, self.w_matrix, size=1).T
+                    + random_generator.multivariate_normal(mean_state_noise, self.w_matrix, size=1).T
                 )
             else:
                 state[:, [i]] = (
                     self.g_matrix @ state[:, [i - 1]]
-                    + np.random.multivariate_normal(mean_state_noise, self.w_matrix, size=1).T
+                    + random_generator.multivariate_normal(mean_state_noise, self.w_matrix, size=1).T
                 )
             obs[:, [i]] = (
                 self.f_matrix.T @ state[:, [i]]
-                + np.random.multivariate_normal(mean_observation_noise, self.v_matrix, size=1).T
+                + random_generator.multivariate_normal(mean_observation_noise, self.v_matrix, size=1).T
             )
 
         return state, obs

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/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
@@ -38,6 +40,9 @@ from pyelq.support_functions.post_processing import (
 if TYPE_CHECKING:
     from pyelq.model import ELQModel
 
+RGB_LIGHT_BLUE = "rgb(102, 197, 204)"
+MCMC_ITERATION_NUMBER_LITERAL = "MCMC Iteration Number"
+
 
 def lighter_rgb(rbg_string: str) -> str:
     """Takes in an RGB string and returns a lighter version of this colour.
@@ -162,16 +167,9 @@ def create_trace_specifics(object_to_plot: Union[Type[SlabAndSpike], SourceModel
     if isinstance(object_to_plot, SourceModel):
         dict_key = kwargs.pop("dict_key", "number_of_sources_plot")
         title_text = "Number of Sources 'on' against MCMC iterations"
-        x_label = "MCMC Iteration Number"
+        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'"
@@ -179,11 +177,11 @@ def create_trace_specifics(object_to_plot: Union[Type[SlabAndSpike], SourceModel
     elif isinstance(object_to_plot, MCMC):
         dict_key = kwargs.pop("dict_key", "log_posterior_plot")
         title_text = "Log posterior values against MCMC iterations"
-        x_label = "MCMC Iteration Number"
+        x_label = MCMC_ITERATION_NUMBER_LITERAL
         y_label = "Log Posterior<br>Value"
         y_values = object_to_plot.store["log_post"].flatten()
         x_values = np.array(range(y_values.size))
-        color = "rgb(102, 197, 204)"
+        color = RGB_LIGHT_BLUE
         name = "Log Posterior"
 
         if "burn_in" not in kwargs:
@@ -245,7 +243,7 @@ def create_plot_specifics(
         if plot_type == "line":
             dict_key = kwargs.pop("dict_key", "error_model_iterations")
             title_text = "Estimated Error Model Values"
-            x_label = "MCMC Iteration Number"
+            x_label = MCMC_ITERATION_NUMBER_LITERAL
             y_label = "Estimated Error Model<br>Standard Deviation (ppm)"
 
         elif plot_type == "box":
@@ -270,7 +268,7 @@ def create_plot_specifics(
         if plot_type == "line":
             dict_key = kwargs.pop("dict_key", "offset_iterations")
             title_text = f"Estimated Value of Offset w.r.t. {offset_sensor_name}"
-            x_label = "MCMC Iteration Number"
+            x_label = MCMC_ITERATION_NUMBER_LITERAL
             y_label = "Estimated Offset<br>Value (ppm)"
 
         elif plot_type == "box":
@@ -816,7 +814,7 @@ class Plot:
 
         dict_key = "estimated_values_plot"
         title_text = "Estimated Values of Sources With Respect to MCMC Iterations"
-        x_label = "MCMC Iteration Number"
+        x_label = MCMC_ITERATION_NUMBER_LITERAL
         y_label = "Estimated Emission<br>Values (kg/hr)"
 
         fig = go.Figure()
@@ -833,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(102, 197, 204)",
-                name=f"Source {source_idx}",
+                color=RGB_LIGHT_BLUE,
+                name=source_label,
                 burn_in=burn_in,
                 show_legend=False,
                 legend_group="Source traces",
@@ -849,7 +851,7 @@ class Plot:
             fig=fig,
             x_values=np.array([None]),
             y_values=np.array([None]),
-            color="rgb(102, 197, 204)",
+            color=RGB_LIGHT_BLUE,
             name="Source traces",
             burn_in=0,
             show_legend=True,
@@ -970,6 +972,7 @@ 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,
@@ -978,12 +981,14 @@ class Plot:
     ):
         """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.
@@ -993,16 +998,26 @@ class Plot:
             show_summary_results (bool, optional): Flag to show the summary results on the map. 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,
@@ -1040,7 +1055,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()
@@ -1066,7 +1081,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(
@@ -1091,9 +1106,41 @@ 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)
 
+        colormap_fixed = px.colors.qualitative.G10
+        marker_dict = {"size": 10, "opacity": 0.8}
+        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()
+                source_location_fixed_average = LLA(
+                    latitude=np.nanmean(source_location_fixed_lla.latitude, axis=1),
+                    longitude=np.nanmean(source_location_fixed_lla.longitude, axis=1),
+                    altitude=np.nanmean(source_location_fixed_lla.altitude, axis=1),
+                )
+
+                for lat_fixed, lon_fixed, label_fixed in zip(
+                    source_location_fixed_average.latitude,
+                    source_location_fixed_average.longitude,
+                    source_model_fixed.individual_source_labels,
+                ):
+                    color_idx = source_model_fixed.individual_source_labels.index(label_fixed)
+                    marker_dict["color"] = colormap_fixed[color_idx % len(colormap_fixed)]
+
+                    fixed_source_location_trace = go.Scattermap(
+                        mode="markers",
+                        lon=np.array(lon_fixed),
+                        lat=np.array(lat_fixed),
+                        name=label_fixed,
+                        marker=marker_dict,
+                    )
+                    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/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
 
 

{pyelq-1.1.1.dist-info → pyelq-1.1.3.dist-info}/METADATA

@@ -1,19 +1,21 @@
 Metadata-Version: 2.3
 Name: pyelq
-Version: 1.1.1
+Version: 1.1.3
 Summary: Package for detection, localization and quantification code.
 License: Apache-2.0
 Keywords: gas dispersion,emission,detection,localization,quantification
 Author: Bas van de Kerkhof
-Requires-Python: >=3.9,<3.12
+Requires-Python: >=3.9
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: geojson (>=3.2.0)
 Requires-Dist: numpy (>=2.0.2)
-Requires-Dist: openmcmc (==1.0.5)
+Requires-Dist: openmcmc (==1.0.6)
 Requires-Dist: pandas (>=2.2.3)
 Requires-Dist: plotly (>=6.0.0)
 Requires-Dist: pymap3d (>=3.1.0)

{pyelq-1.1.1.dist-info → pyelq-1.1.3.dist-info}/RECORD

@@ -4,18 +4,18 @@ pyelq/component/background.py,sha256=kalBr0fck1ktDUoNlLNff805tM2yZI0TVHPbUL5uZ5s
 pyelq/component/component.py,sha256=rOQSWhhnKnx8Vc5MevX9B1rt42UY9gabFKq_7cJFQO8,2360
 pyelq/component/error_model.py,sha256=NLPKEuEPnb2DwaX78CibHy7ioMkljRzwT96Y8h6_sDc,16261
 pyelq/component/offset.py,sha256=RPQLjdzvS-7Moy1u_wAF84DQEEn4MqfW6RMozwf-11g,7718
-pyelq/component/source_model.py,sha256=TqRv67H95QiXmvb7UXzMEuxCyY_3Vvl85cweXReIX4s,38391
+pyelq/component/source_model.py,sha256=eAAI8CDpd9Q474W8-1KA5t9-Zjoa2Jz-hwZ3asOxtLc,44873
 pyelq/coordinate_system.py,sha256=UXk6GOghMxEE3NfWcGPSVsI1q89xEjHTe9sfHbh-gDc,22281
 pyelq/data_access/__init__.py,sha256=hLTVYOMdmEVsckJ5OOCX9jf2Cqw5xRkQnmxCmYCGWXw,186
 pyelq/data_access/data_access.py,sha256=mI2HYxsZCr4vmmV-t85HYlHuZ06GJEBX4ypx9Putou0,3973
 pyelq/dispersion_model/__init__.py,sha256=KN1hyrEBsfoIHd0_u_BGy2n-KliiDr-_7YAHiNzhyT0,194
 pyelq/dispersion_model/gaussian_plume.py,sha256=q19ZB0wJBEAcdTOYb5AUw85T7yGlM7lImXPc2Uh0Gfo,31404
-pyelq/dlm.py,sha256=vt8RU5K50DHwCC3m-2tcHwkVcV7b9ZJFhxmsqyEGp7s,25293
+pyelq/dlm.py,sha256=LnD3BpvYjuHw_MiZaFfamfyJMQTMxd0kay_Z7w_yWH0,25375
 pyelq/gas_species.py,sha256=tQy41zINgI8Q1P1iHKQWU2X48FwtzYb-mCMdYT2yqOc,6908
 pyelq/meteorology.py,sha256=INs_Y-SGVD27re2THTANsgnw81iu9olr-ozA4lnD08U,17433
-pyelq/model.py,sha256=JAQbQcsWlz1lmBxv8nOCCSBnlxg1LsyhICZOGoclGIg,9278
+pyelq/model.py,sha256=P3H_MzQRwQpsK1aW69NcwKNyTuft_MHhsc82uSox8s4,15252
 pyelq/plotting/__init__.py,sha256=E3qUfLWIHlC11-P5GJKOkflKclZB8TzHpRnOZbg9swk,176
-pyelq/plotting/plot.py,sha256=fNx3o5Wj_iOZrgKeBz1M-DqPnpXzpmpDUpK6Ymm2W7E,48405
+pyelq/plotting/plot.py,sha256=T25IINoXjvG9CT7hulJvaV4L6_AzjnFDgR1q5ctBA_U,50555
 pyelq/preprocessing.py,sha256=KDYrfOJSJHePWqdn4rWBum8AKLuO8FzaZBJjTB3uImY,12654
 pyelq/sensor/__init__.py,sha256=RK00UUnv4z45_kAdFoSIUKD6WmzPbbqYOlbyGG-_ZLw,197
 pyelq/sensor/beam.py,sha256=6E7-cH_IoBRgferIcyOWUfnFjnakhpTbnfWDAyABezA,1806
@@ -23,10 +23,10 @@ pyelq/sensor/satellite.py,sha256=2T6NcSPc_YxgnhyOTQz8zlz6IqWl6uSnDTFHGBoy0lI,231
 pyelq/sensor/sensor.py,sha256=t7bqU3222BRS7hXs4pWeTdeB1IkKlFYH6VdNtDU2RbU,9183
 pyelq/source_map.py,sha256=L82dvrZTpVQBy10BhoCJ09-gVO5d90DDwvIdIST9l4g,5741
 pyelq/support_functions/__init__.py,sha256=ZYcVLitB51BXYojlt6FEZ4ciDFkRlA5ZkJvnzWQsdD4,229
-pyelq/support_functions/post_processing.py,sha256=ZAYSKkknjwTbm4v3-rYTS1VXcJkkxGOpCLFTonwBUhY,17580
+pyelq/support_functions/post_processing.py,sha256=MBoe75SifPnsFyooA1oaF-waC-rVxtqEk-HiNjrJpQQ,16996
 pyelq/support_functions/spatio_temporal_interpolation.py,sha256=sU_-9Yz4I1YgNa78_KvRclsaP4LlZiE0HG7_OZ1Vahk,10609
-pyelq-1.1.1.dist-info/LICENSE.md,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-pyelq-1.1.1.dist-info/LICENSES/Apache-2.0.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-pyelq-1.1.1.dist-info/METADATA,sha256=aVNZertL9GtMSnp86dNRiUrWkWn7pUOoMEYcZRZHuUk,8419
-pyelq-1.1.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-pyelq-1.1.1.dist-info/RECORD,,
+pyelq-1.1.3.dist-info/LICENSE.md,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pyelq-1.1.3.dist-info/LICENSES/Apache-2.0.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+pyelq-1.1.3.dist-info/METADATA,sha256=fEhik5aHpYSq4-HtJNvYa_f7GXFzN1aOuhqUf7ppjzY,8515
+pyelq-1.1.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pyelq-1.1.3.dist-info/RECORD,,

{pyelq-1.1.1.dist-info → pyelq-1.1.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any