pyelq 1.1.4__py3-none-any.whl → 1.2.0__py3-none-any.whl

pyelq/__init__.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 """Main pyELQ module."""
+
 __all__ = [
     "component",
     "data_access",

pyelq/component/__init__.py

@@ -3,4 +3,5 @@
 # SPDX-License-Identifier: Apache-2.0
 
 """Components Module."""
+
 __all__ = ["background", "component", "error_model", "offset", "source_model"]

pyelq/component/background.py

@@ -1,7 +1,6 @@
 # SPDX-FileCopyrightText: 2024 Shell Global Solutions International B.V. All Rights Reserved.
 #
 # SPDX-License-Identifier: Apache-2.0
-
 """Model components for background modelling."""
 
 from abc import abstractmethod
@@ -22,7 +21,7 @@ from sklearn.neighbors import NearestNeighbors
 from pyelq.component.component import Component
 from pyelq.coordinate_system import Coordinate
 from pyelq.gas_species import GasSpecies
-from pyelq.meteorology import MeteorologyGroup
+from pyelq.meteorology.meteorology import MeteorologyGroup
 from pyelq.sensor.beam import Beam
 from pyelq.sensor.sensor import SensorGroup
 
@@ -51,6 +50,7 @@ class Background(Component):
         initial_precision (float): initial value for the scalar precision parameter.
         basis_matrix (sparse.csr_array): [n_obs x n_time] matrix mapping the background model parameters on to the
             observations.
+        precision_time_0 (float): precision relating to the first time stamp in the model. Defaults to 0.01.
 
     """
 
@@ -65,6 +65,7 @@ class Background(Component):
     prior_precision_rate: float = 1e-3
     initial_precision: float = 1.0
     basis_matrix: sparse.csr_array = field(init=False)
+    precision_time_0: float = field(init=False, default=0.01)
 
     @abstractmethod
     def initialise(self, sensor_object: SensorGroup, meteorology: MeteorologyGroup, gas_species: GasSpecies):
@@ -168,6 +169,9 @@ class TemporalBackground(Background):
     def initialise(self, sensor_object: SensorGroup, meteorology: MeteorologyGroup, gas_species: GasSpecies):
         """Create temporal background model from sensor, meteorology and gas species inputs.
 
+        The precision matrix is made to be full rank by adjusting the precision at the first time point using the
+        precision_time_0 attribute.
+
         Args:
             sensor_object (SensorGroup): sensor data object.
             meteorology (MeteorologyGroup): meteorology data object.
@@ -180,6 +184,8 @@ class TemporalBackground(Background):
         self.n_parameter = len(self.time)
         self.basis_matrix = sparse.csr_array((np.ones(self.n_obs), (np.array(range(self.n_obs)), unique_inverse)))
         self.precision_matrix = gmrf.precision_temporal(time=self.time)
+        lam = self.precision_matrix[0, 0]
+        self.precision_matrix[0, 0] = lam * (2.0 - lam / (self.precision_time_0 + lam))
         if self.mean_bg is None:
             self.mean_bg = gas_species.global_background
 
@@ -193,8 +199,8 @@ class SpatioTemporalBackground(Background):
     The background parameter is an [n_location * n_time x 1] (if self.spatial_dependence is True) or an [n_time x 1]
     vector (if self.spatial_dependence is False). In the spatio-temporal case, the background vector is assumed to
     unwrap over space and time as follows:
-    bg = [b_1(t_1), b_2(t_1),..., b_nlct(t_1),...,b_1(t_k),..., b_nlct(t_k),...].T
-    where nlct is the number of sensor locations.
+    bg = [b_1(t_1), b_2(t_1),..., b_n_lct(t_1),...,b_1(t_k),..., b_n_lct(t_k),...].T
+    where n_lct is the number of sensor locations.
     This unwrapping mechanism is chosen as it greatly speeds up the sparse matrix operations in the solver (vs. the
     alternative).
 
@@ -226,7 +232,6 @@ class SpatioTemporalBackground(Background):
         spatial_precision_matrix (np.ndarray): spatial component of the precision matrix. The full model precision
             matrix is the Kronecker product of this matrix with the self.temporal_precision_matrix. Simply set to 1 if
             self.spatial_dependence is False.
-        precision_time_0 (float): precision relating to the first time stamp in the model. Defaults to 0.01.
 
     """
 
@@ -238,7 +243,6 @@ class SpatioTemporalBackground(Background):
     location: Coordinate = field(init=False)
     temporal_precision_matrix: Union[np.ndarray, sparse.csc_matrix] = field(init=False)
     spatial_precision_matrix: np.ndarray = field(init=False)
-    precision_time_0: float = field(init=False, default=0.01)
 
     def initialise(self, sensor_object: SensorGroup, meteorology: MeteorologyGroup, gas_species: GasSpecies):
         """Take data inputs and extract relevant properties.
@@ -303,10 +307,9 @@ class SpatioTemporalBackground(Background):
             self.time = pd.array(np.unique(sensor_object.time), dtype="datetime64[ns]")
             self.n_time = len(self.time)
         else:
-            self.time = pd.array(
-                pd.date_range(start=np.min(sensor_object.time), end=np.max(sensor_object.time), periods=self.n_time),
-                dtype="datetime64[ns]",
-            )
+            self.time = pd.date_range(
+                start=np.min(sensor_object.time), end=np.max(sensor_object.time), periods=self.n_time
+            ).array
 
     def make_spatial_knots(self, sensor_object: SensorGroup):
         """Create the spatial grid for the model.
@@ -333,6 +336,9 @@ class SpatioTemporalBackground(Background):
 
         Defined as the Kronecker product of the temporal precision matrix and the spatial precision matrix.
 
+        The precision matrix is made to be full rank by adjusting the precision at the first time point using the
+        precision_time_0 attribute.
+
         """
         self.temporal_precision_matrix = gmrf.precision_temporal(time=self.time)
         lam = self.temporal_precision_matrix[0, 0]
@@ -386,6 +392,6 @@ class SpatioTemporalBackground(Background):
                 self.location.north[k] = np.mean(sensor.location.to_enu().north, axis=0)
                 self.location.up[k] = np.mean(sensor.location.to_enu().up, axis=0)
             else:
-                self.location.east[k] = sensor.location.to_enu().east
-                self.location.north[k] = sensor.location.to_enu().north
-                self.location.up[k] = sensor.location.to_enu().up
+                self.location.east[k] = sensor.location.to_enu().east.item()
+                self.location.north[k] = sensor.location.to_enu().north.item()
+                self.location.up[k] = sensor.location.to_enu().up.item()

pyelq/component/component.py

@@ -3,13 +3,14 @@
 # SPDX-License-Identifier: Apache-2.0
 
 """Superclass for model components."""
+
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
 from openmcmc.model import Model
 
 from pyelq.gas_species import GasSpecies
-from pyelq.meteorology import MeteorologyGroup
+from pyelq.meteorology.meteorology import MeteorologyGroup
 from pyelq.sensor.sensor import SensorGroup
 
 

pyelq/component/error_model.py

@@ -4,6 +4,7 @@
 
 # -*- coding: utf-8 -*-
 """Error model module."""
+
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Union
 
@@ -15,7 +16,7 @@ from openmcmc.sampler.sampler import NormalGamma
 
 from pyelq.component.component import Component
 from pyelq.gas_species import GasSpecies
-from pyelq.meteorology import MeteorologyGroup
+from pyelq.meteorology.meteorology import MeteorologyGroup
 from pyelq.sensor.sensor import Sensor, SensorGroup
 
 if TYPE_CHECKING:

pyelq/component/offset.py

@@ -4,6 +4,7 @@
 
 # -*- coding: utf-8 -*-
 """Offset module."""
+
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Union
 
@@ -17,7 +18,7 @@ from scipy import sparse
 
 from pyelq.component.component import Component
 from pyelq.gas_species import GasSpecies
-from pyelq.meteorology import Meteorology
+from pyelq.meteorology.meteorology import Meteorology
 from pyelq.sensor.sensor import Sensor, SensorGroup
 
 if TYPE_CHECKING:

pyelq/component/source_model.py

@@ -34,7 +34,7 @@ from pyelq.component.component import Component
 from pyelq.coordinate_system import ENU
 from pyelq.dispersion_model.gaussian_plume import GaussianPlume
 from pyelq.gas_species import GasSpecies
-from pyelq.meteorology import Meteorology
+from pyelq.meteorology.meteorology import Meteorology
 from pyelq.sensor.sensor import SensorGroup
 from pyelq.source_map import SourceMap
 
@@ -221,6 +221,7 @@ class NullGrouping(SourceGrouping):
 
         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)
 
@@ -482,6 +483,8 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
 
         reversible_jump (bool): logical indicating whether the reversible jump algorithm for estimation of the number
             of sources and their locations should be run. Defaults to False.
+        distribution_number_sources (str): distribution for the number of sources in the solution. Can be either
+            "Poisson" or "Uniform". Defaults to "Poisson".
         random_walk_step_size (np.ndarray): (3 x 1) array specifying the standard deviations of the distributions
             from which the random walk sampler draws new source locations. Defaults to np.array([1.0, 1.0, 0.1]).
         site_limits (np.ndarray): (3 x 2) array specifying the lower (column 0) and upper (column 1) limits of the
@@ -489,7 +492,7 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
             the solution).
         rate_num_sources (int): specification for the parameter for the Poisson prior distribution for the total number
             of sources. Only relevant for cases where reversible_jump == True (where the number of sources in the
-            solution can change).
+            solution can change). Unused in the case of a Uniform prior (self.distribution_number_sources == "Uniform").
         n_sources_max (int): maximum number of sources that can feature in the solution. Only relevant for cases where
             reversible_jump == True (where the number of sources in the solution can change).
         emission_proposal_std (float): standard deviation of the truncated Gaussian distribution used to propose the
@@ -528,6 +531,7 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
     gas_species: GasSpecies = field(init=False, default=None)
 
     reversible_jump: bool = False
+    distribution_number_sources: str = "Poisson"
     random_walk_step_size: np.ndarray = field(default_factory=lambda: np.array([1.0, 1.0, 0.1], ndmin=2).T)
     site_limits: np.ndarray = None
     rate_num_sources: int = 5
@@ -553,9 +557,9 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
     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.
+        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)
@@ -589,9 +593,10 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
         self.coupling = self.dispersion_model.compute_coupling(
             sensor_object, meteorology, gas_species, output_stacked=True
         )
+
+        self.sensor_object = sensor_object
         self.screen_coverage()
         if self.reversible_jump:
-            self.sensor_object = sensor_object
             self.meteorology = meteorology
             self.gas_species = gas_species
 
@@ -630,14 +635,45 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
 
     def screen_coverage(self):
         """Screen the initial source map for coverage."""
-        in_coverage_area = self.dispersion_model.compute_coverage(
-            self.coupling, coverage_threshold=self.coverage_threshold, threshold_function=self.threshold_function
-        )
+        in_coverage_area = self.compute_coverage(self.coupling)
         self.coupling = self.coupling[:, in_coverage_area]
         all_locations = self.dispersion_model.source_map.location.to_array()
         screened_locations = all_locations[in_coverage_area, :]
         self.dispersion_model.source_map.location.from_array(screened_locations)
 
+    def compute_coverage(self, couplings: np.ndarray, **kwargs) -> np.ndarray:
+        """Returns a logical vector that indicates which sources in the couplings are, or are not, within the coverage.
+
+        The 'coverage' is the area inside which all sources are well covered by wind data. E.g. If wind exclusively
+        blows towards East, then all sources to the East of any sensor are 'invisible', and are not within the coverage.
+
+        Couplings are returned in hr/kg. Some threshold function defines the largest allowed coupling value. This is
+        used to calculate estimated emission rates in kg/hr. Any emissions which are greater than the value of
+        'self.coverage_threshold' are defined as not within the coverage.
+
+        If sensor_object.source_on is being used only the parts where th coupling is computed are used in the coverage
+        check. This avoids threshold_function being affected by large amounts of zero values.
+
+        Args:
+            couplings (np.ndarray): Array of coupling values. Dimensions: n_data points x n_sources.
+            kwargs (dict, optional): Keyword arguments required for the threshold function.
+
+        Returns:
+            coverage (np.ndarray): A logical array specifying which sources are within the coverage.
+
+        """
+        if self.sensor_object.source_on is not None:
+            couplings = deepcopy(couplings)
+            index_keep = self.sensor_object.source_on > 0
+            couplings = couplings[index_keep]
+
+        coupling_threshold = self.threshold_function(couplings, **kwargs)
+        no_warning_threshold = np.where(coupling_threshold <= 1e-100, 1, coupling_threshold)
+        no_warning_estimated_emission_rates = np.where(coupling_threshold <= 1e-100, np.inf, 1 / no_warning_threshold)
+        coverage = no_warning_estimated_emission_rates < self.coverage_threshold
+
+        return coverage
+
     def update_coupling_column(self, state: dict, update_column: int) -> dict:
         """Update the coupling, based on changes to the source locations as part of inversion.
 
@@ -710,15 +746,11 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
                 (i.e. log[p(current | proposed)])
 
         """
-        prop_state = self.update_coupling_column(prop_state, int(prop_state[self.map["number_sources"]]) - 1)
+        prop_state = self.update_coupling_column(prop_state, int(prop_state[self.map["number_sources"]].item()) - 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[self.map["coupling_matrix"]][:, -1],
-            coverage_threshold=self.coverage_threshold,
-            threshold_function=self.threshold_function,
-        )
+        in_cov_area = self.compute_coverage(prop_state[self.map["coupling_matrix"]][:, -1])
         if not in_cov_area:
             logp_pr_g_cr = 1e10
         else:
@@ -760,30 +792,34 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
 
         return prop_state, logp_pr_g_cr, logp_cr_g_pr
 
-    def move_function(self, current_state: dict, update_column: int) -> dict:
+    def move_function(self, prop_state: dict, update_column: int) -> Tuple[dict, float, float]:
         """Re-compute the coupling after a source location move.
 
         Function first updates the coupling column, and then checks whether the location passes a coverage test. If the
-        location does not have good enough coverage, the state reverts to the coupling from the current state.
+        location does not have good enough coverage, we return a high log-probability of the move to reject.
 
         Args:
-            current_state (dict): dictionary containing parameters of the current state.
+            prop_state (dict): dictionary containing parameters of the proposed state.
             update_column (int): index of the coupling column to be updated.
 
         Returns:
-            dict: proposed state, with updated coupling matrix.
+            prop_state (dict): proposed state, with coupling matrix and source emission rate vector updated.
+            logp_pr_g_cr (float): log-transition density of the proposed state given the current state
+                (i.e. log[p(proposed | current)])
+            logp_cr_g_pr (float): log-transition density of the current state given the proposed state
+                (i.e. log[p(current | proposed)])
 
         """
-        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[self.map["coupling_matrix"]][:, update_column],
-            coverage_threshold=self.coverage_threshold,
-            threshold_function=self.threshold_function,
-        )
+        in_cov_area = self.compute_coverage(prop_state[self.map["coupling_matrix"]][:, update_column])
+
         if not in_cov_area:
-            prop_state = deepcopy(current_state)
-        return prop_state
+            logp_pr_g_cr = 1e10
+        else:
+            logp_pr_g_cr = 0.0
+        logp_cr_g_pr = 0.0
+
+        return prop_state, logp_pr_g_cr, logp_cr_g_pr
 
     def make_model(self, model: list) -> list:
         """Take model list and append new elements from current model component.
@@ -813,7 +849,18 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
                     domain_response_upper=self.site_limits[:, [1]],
                 )
             )
-            model.append(Poisson(response=self.map["number_sources"], rate=self.map["number_source_rate"]))
+            if self.distribution_number_sources == "Uniform":
+                model.append(
+                    Uniform(
+                        response=self.map["number_sources"],
+                        domain_response_lower=1,
+                        domain_response_upper=self.n_sources_max,
+                    )
+                )
+            elif self.distribution_number_sources == "Poisson":
+                model.append(Poisson(response=self.map["number_sources"], rate=self.map["number_source_rate"]))
+            else:
+                raise ValueError("Invalid distribution type for number of sources.")
         return model
 
     def make_sampler(self, model: Model, sampler_list: list) -> list:
@@ -854,7 +901,9 @@ class SourceModel(Component, SourceGrouping, SourceDistribution):
             state[self.map["precision_prior_rate"]] = np.ones_like(self.initial_precision) * self.prior_precision_rate
         if self.reversible_jump:
             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_sources"]] = np.array(
+                state[self.map["source_location"]].shape[1], ndmin=2, dtype=int
+            )
             state[self.map["number_source_rate"]] = self.rate_num_sources
         return state
 

pyelq/coordinate_system.py

@@ -10,6 +10,7 @@ pyELQ. Each coordinate system has relevant methods for features that are commonl
 conversions between each of the systems, alongside some functionality for interpolation.
 
 """
+
 from abc import ABC, abstractmethod
 from copy import deepcopy
 from dataclasses import dataclass, field

pyelq/data_access/__init__.py

@@ -2,4 +2,5 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 """Data Access Module."""
+
 __all__ = ["data_access"]

pyelq/data_access/data_access.py

@@ -16,7 +16,7 @@ from typing import Any, Union
 
 import pandas as pd
 
-from pyelq.meteorology import Meteorology, MeteorologyGroup
+from pyelq.meteorology.meteorology import Meteorology, MeteorologyGroup
 from pyelq.sensor.sensor import Sensor, SensorGroup
 
 

pyelq/dispersion_model/__init__.py

@@ -1,5 +1,6 @@
-# SPDX-FileCopyrightText: 2024 Shell Global Solutions International B.V. All Rights Reserved.
+# SPDX-FileCopyrightText: 2026 Shell Global Solutions International B.V. All Rights Reserved.
 #
 # SPDX-License-Identifier: Apache-2.0
-"""Dispersion Model Module."""
-__all__ = ["gaussian_plume"]
+"""Data Access Module."""
+
+__all__ = ["dispersion_model", "finite_volume", "gaussian_plume", "site_layout"]

pyelq/dispersion_model/dispersion_model.py

@@ -0,0 +1,202 @@
+# SPDX-FileCopyrightText: 2026 Shell Global Solutions International B.V. All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# -*- coding: utf-8 -*-
+"""DispersionModel module.
+
+The super class for the Gaussian Plume and Finite Volume dispersion models used in pyELQ.
+
+The Mathematics of Atmospheric Dispersion Modeling, John M. Stockie, DOI. 10.1137/10080991X
+
+"""
+
+from abc import ABC
+from dataclasses import dataclass
+from typing import Union
+
+import numpy as np
+
+import pyelq.support_functions.spatio_temporal_interpolation as sti
+from pyelq.gas_species import GasSpecies
+from pyelq.meteorology.meteorology import Meteorology
+from pyelq.sensor.satellite import Satellite
+from pyelq.sensor.sensor import Sensor
+from pyelq.source_map import SourceMap
+
+
+@dataclass
+class DispersionModel(ABC):
+    """Defines the dispersion model class.
+
+    Attributes:
+        source_map (Sourcemap): SourceMap object used for the dispersion model.
+        minimum_contribution (float): All elements in the plume coupling smaller than this number will be set
+            to 0. Helps to speed up matrix multiplications/matrix inverses, also helps with stability.
+
+    """
+
+    source_map: SourceMap
+    minimum_contribution: float = 0
+
+    def calculate_gas_density(
+        self,
+        meteorology: Meteorology,
+        sensor_object: Sensor,
+        gas_object: Union[GasSpecies, None],
+        run_interpolation: bool = True,
+    ) -> np.ndarray:
+        """Helper function to calculate the gas density using ideal gas law.
+
+        https://en.wikipedia.org/wiki/Ideal_gas
+
+        When a gas object is passed as input we calculate the density according to that gas. We check if the
+        meteorology object has a temperature and/or pressure value and use those accordingly. Otherwise, we use Standard
+        Temperature and Pressure (STP).
+
+        If run_interpolation is True, we interpolate the temperature and pressure values to the source locations/times
+        such that this is consistent with the other calculations, i.e. we only do spatial interpolation when the sensor
+        is a Satellite object and temporal interpolation otherwise.
+
+        When no gas_object is passed in we just set the gas density value to 1.
+
+        Args:
+            meteorology (Meteorology): Meteorology object potentially containing temperature or pressure values
+            sensor_object (Sensor): Sensor object containing information about where to interpolate to
+            gas_object (Union[GasSpecies, None]): Gas species object which actually calculates the correct density
+            run_interpolation (bool): Flag indicating whether to run interpolation, defaults to True.
+
+        Returns:
+            gas_density (np.ndarray): Numpy array of shape [1 x nof_sources] (Satellite sensor)
+                or [nof_observations x 1] (otherwise) containing the gas density values to use
+
+        """
+        if not isinstance(gas_object, GasSpecies):
+            if isinstance(sensor_object, Satellite):
+                return np.ones((1, self.source_map.nof_sources))
+            return np.ones((sensor_object.nof_observations, 1))
+
+        if meteorology.temperature is None:
+            temperature = np.array([[273.15]])
+
+        elif run_interpolation:
+            temperature = self.interpolate_meteorology(
+                meteorology=meteorology, variable_name="temperature", sensor_object=sensor_object
+            )
+        else:
+            temperature = meteorology.temperature
+
+        if meteorology.pressure is None:
+            pressure = np.array([[101.325]])
+        elif run_interpolation:
+            pressure = self.interpolate_meteorology(
+                meteorology=meteorology, variable_name="pressure", sensor_object=sensor_object
+            )
+        else:
+            pressure = meteorology.pressure
+
+        gas_density = gas_object.gas_density(temperature=temperature, pressure=pressure)
+        return gas_density
+
+    def interpolate_all_meteorology(
+        self,
+        sensor_object: Sensor,
+        meteorology: Meteorology,
+        gas_object: Union[GasSpecies, None],
+        run_interpolation: bool,
+    ):
+        """Function which carries out interpolation of all meteorological information.
+
+        The flag run_interpolation determines whether the interpolation should be carried out. If this is set to be
+        False, the meteorological parameters are simply set to the values stored on the meteorology object (i.e. we
+        assume that the meteorology has already been interpolated). This functionality is required to avoid wasted
+        computation in the case of e.g. a reversible jump run.
+
+        Args:
+            sensor_object (Sensor): object containing locations/times onto which met information should
+                be interpolated.
+            meteorology (Meteorology): object containing meteorology information for interpolation.
+            gas_object (Union[GasSpecies, None]): object containing gas information.
+            run_interpolation (bool): logical indicating whether the meteorology information needs to be interpolated.
+
+        Returns:
+            gas_density (np.ndarray): numpy array of shape [n_data x 1] of gas densities.
+            u_interpolated (np.ndarray): numpy array of shape [n_data x 1] of northerly wind components.
+            v_interpolated (np.ndarray): numpy array of shape [n_data x 1] of easterly wind components.
+            wind_turbulence_horizontal (np.ndarray): numpy array of shape [n_data x 1] of horizontal turbulence
+                parameters.
+            wind_turbulence_vertical (np.ndarray): numpy array of shape [n_data x 1] of vertical turbulence
+                parameters.
+
+        """
+        if run_interpolation:
+            gas_density = self.calculate_gas_density(
+                meteorology=meteorology, sensor_object=sensor_object, gas_object=gas_object
+            )
+            u_interpolated = self.interpolate_meteorology(
+                meteorology=meteorology, variable_name="u_component", sensor_object=sensor_object
+            )
+            v_interpolated = self.interpolate_meteorology(
+                meteorology=meteorology, variable_name="v_component", sensor_object=sensor_object
+            )
+            wind_turbulence_horizontal = self.interpolate_meteorology(
+                meteorology=meteorology, variable_name="wind_turbulence_horizontal", sensor_object=sensor_object
+            )
+            wind_turbulence_vertical = self.interpolate_meteorology(
+                meteorology=meteorology, variable_name="wind_turbulence_vertical", sensor_object=sensor_object
+            )
+        else:
+            if gas_object is None:
+                gas_density = np.ones((meteorology.nof_observations, 1))
+            else:
+                gas_density = gas_object.gas_density(temperature=meteorology.temperature, pressure=meteorology.pressure)
+                gas_density = gas_density.reshape((gas_density.size, 1))
+            u_interpolated = meteorology.u_component.reshape((meteorology.u_component.size, 1))
+            v_interpolated = meteorology.v_component.reshape((meteorology.v_component.size, 1))
+            wind_turbulence_horizontal = meteorology.wind_turbulence_horizontal.reshape(
+                (meteorology.wind_turbulence_horizontal.size, 1)
+            )
+            wind_turbulence_vertical = meteorology.wind_turbulence_vertical.reshape(
+                (meteorology.wind_turbulence_vertical.size, 1)
+            )
+
+        return gas_density, u_interpolated, v_interpolated, wind_turbulence_horizontal, wind_turbulence_vertical
+
+    def interpolate_meteorology(
+        self, meteorology: Meteorology, variable_name: str, sensor_object: Sensor
+    ) -> Union[np.ndarray, None]:
+        """Helper function to interpolate meteorology variables.
+
+        This function interpolates meteorological variables to times in Sensor or Sources in sourcemap. It also
+        calculates the wind speed and mathematical angle between the u- and v-components which in turn gets used in the
+        calculation of the Gaussian plume.
+
+        When the input sensor object is a Satellite type we use spatial interpolation using the interpolation method
+        from the coordinate system class as this takes care of the coordinate systems.
+        When the input sensor object is of another time we use temporal interpolation (assumption is spatial uniformity
+        for all observations over a small(er) area).
+
+        Args:
+            meteorology (Meteorology): Meteorology object containing u- and v-components of wind including their
+                spatial location
+            variable_name (str): String name of an attribute in the meteorology input object which needs to be
+                interpolated
+            sensor_object (Sensor): Sensor object containing information about where to interpolate to
+
+        Returns:
+            variable_interpolated (np.ndarray): Interpolated values
+
+        """
+        variable = getattr(meteorology, variable_name)
+        if variable is None:
+            return None
+
+        if isinstance(sensor_object, Satellite):
+            variable_interpolated = meteorology.location.interpolate(variable, self.source_map.location)
+            variable_interpolated = variable_interpolated.reshape(1, self.source_map.nof_sources)
+        else:
+            variable_interpolated = sti.interpolate(
+                time_in=meteorology.time, values_in=variable, time_out=sensor_object.time
+            )
+            variable_interpolated = variable_interpolated.reshape(sensor_object.nof_observations, 1)
+        return variable_interpolated