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

pyelq/meteorology/meteorology_windfield.py

@@ -0,0 +1,180 @@
+# SPDX-FileCopyrightText: 2026 Shell Global Solutions International B.V. All Rights Reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# -*- coding: utf-8 -*-
+"""Meteorology windfield module.
+
+Version of the meteorology class that deals with spatial wind fields and can calculate the wind field around
+cylindrical obstacles.
+
+"""
+
+from dataclasses import dataclass
+from typing import Optional, Tuple, Union
+
+import numpy as np
+
+from pyelq.coordinate_system import ENU
+from pyelq.dispersion_model.site_layout import SiteLayout
+from pyelq.meteorology.meteorology import Meteorology
+
+
+@dataclass
+class MeteorologyWindfield(Meteorology):
+    """Represents a spatially resolved wind field based on meteorological measurements and the presence of obstacles.
+
+    This class extends the base `Meteorology` class by providing methods to compute the local wind vector (u and v
+    components) at every grid point, factoring in obstacle perturbations using an analytical method. It accounts for
+    spatial rotation to align with the instantaneous wind direction at each time step.
+
+    Attributes:
+        static_wind_field (Meteorology): The static wind field used for calculations.
+        site_layout (SiteLayout): The layout of the site, including cylinder coordinates and radii.
+
+    """
+
+    static_wind_field: Meteorology
+    site_layout: Optional[Union[SiteLayout, None]] = None
+
+    def calculate_spatial_wind_field(self, grid_coordinates: ENU, time_index: int = None):
+        """Calculates the spatial wind field over a grid considering obstacles.
+
+        Computes the full spatial wind field from a time series stored in self.static_wind_field at grid locations
+        provided in grid_coordinates considering distortion effects due to flow around cylindrical obstacles.
+
+        The method:
+        - Rotates grid coordinates into the wind-aligned frame based on mathematical wind direction.
+        - Calculates the distorted wind field due to the presence of cylindrical obstacles.
+        - Rotates the resulting local wind field back into the original frame.
+        - Updates the object's `u_component` and `v_component` accordingly.
+        - If w_component is present in the static wind field, it is broadcasted to match the grid points.
+        - If no site layout is provided, the wind field remains undisturbed and is simply broadcasted across the grid.
+
+        Output: The method updates the following properties in place:
+        - u_component np.ndarray: (n_grid x n_time) The x-component of the wind field at the grid points.
+        - v_component np.ndarray: (n_grid x n_time) The y-component of the wind field at the grid points.
+        - w_component np.ndarray: (n_grid x n_time) The z-component of the wind field at the grid points.
+
+        Args:
+            grid_coordinates (ENU): The coordinates of the grid points.
+            time_index (int): The time index for the meteorological data.
+
+        """
+        if time_index is None:
+            time_index = np.ones_like(self.static_wind_field.u_component).astype(bool)
+
+        u = self.static_wind_field.u_component.reshape(-1, 1)[time_index]
+        v = self.static_wind_field.v_component.reshape(-1, 1)[time_index]
+        if self.static_wind_field.w_component is not None:
+            self.w_component = np.broadcast_to(
+                self.static_wind_field.w_component[time_index].T,
+                (grid_coordinates.nof_observations, u.shape[0]),
+            )
+
+        if self.site_layout is None:
+            self.u_component = np.broadcast_to(u.T, (grid_coordinates.nof_observations, u.shape[0]))
+            self.v_component = np.broadcast_to(v.T, (grid_coordinates.nof_observations, v.shape[0]))
+            return
+        mathematical_wind_direction = np.arctan2(v, u).flatten()
+        rotation_matrix, rotated_grid, rotated_cylinders = self._rotate_coordinates(
+            grid_coordinates, mathematical_wind_direction
+        )
+        u_rot, v_rot = self._calculate_wind_field_cardinal(
+            u=u,
+            v=v,
+            grid_coordinates=grid_coordinates,
+            rotated_grid=rotated_grid,
+            rotated_cylinders=rotated_cylinders,
+        )
+        u_stacked = np.stack((u_rot, v_rot), axis=2)
+        inverse_rot = np.transpose(rotation_matrix, axes=(1, 0, 2))
+        rotated_wind = np.einsum("ijt,ntj-> nti", inverse_rot, u_stacked)
+        self.u_component = rotated_wind[:, :, 0]
+        self.v_component = rotated_wind[:, :, 1]
+
+    def _rotate_coordinates(
+        self, grid_coordinates: ENU, wind_direction: np.ndarray
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Rotates the x, y coordinates based on the wind direction.
+
+        Args:
+            grid_coordinates (ENU): The coordinates to be rotated.
+            wind_direction (np.array): The wind direction in radians.
+
+        Returns:
+            rotation_matrix (np.ndarray): rotation matrix used for inverse rotation
+            rotated_grid (np.ndarray): grid_coordinates in rotated coordinate system
+            rotated_cylinders (np.ndarray): cylinder locations in rotated coordinate system
+
+        """
+        rotation_matrix = np.array(
+            [
+                [np.cos(wind_direction), np.sin(wind_direction)],
+                [-np.sin(wind_direction), np.cos(wind_direction)],
+            ]
+        )
+        rotated_grid = np.einsum("ijt,nj->nit", rotation_matrix, grid_coordinates.to_array(dim=2))
+        rotated_cylinders = np.einsum(
+            "ijt,nj->nit", rotation_matrix, self.site_layout.cylinder_coordinates.to_array(dim=2)
+        )
+        return rotation_matrix, rotated_grid, rotated_cylinders
+
+    def _calculate_wind_field_cardinal(
+        self,
+        u: np.ndarray,
+        v: np.ndarray,
+        grid_coordinates: ENU,
+        rotated_grid: np.ndarray,
+        rotated_cylinders: np.ndarray,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """Calculates the distorted wind field components (u, v) in the wind-aligned (cardinal) frame.
+
+        The method:
+        - Determines whether each grid point is influenced by nearby cylinders based on distance and cylinder radius.
+        - If no obstacles are relevant at the evaluation height, the wind field remains undisturbed.
+        - If obstacles are present, modifies the wind field using an analytical perturbation formula based on
+            potential flow theory.
+        - Wind inside obstacles is set to zero.
+
+        If no height information is provided (e.g. in the 2-dimensional solver case), the function assumes that
+        all cylinders and input points are at the same height, and applies the mask accordingly.
+
+        Args:
+            u (np.ndarray n_time x 1): The x-component of the wind vector.
+            v (np.ndarray  n_time x 1): The y-component of the wind vector.
+            grid_coordinates (ENU): location object containing information about the finite volume solve grid points.
+            rotated_grid (np.ndarray n_grid x 2 x n_time): The grid coordinates where the wind field is to be calculated
+            in the wind-aligned frame.
+            rotated_cylinders (np.ndarray n_cylinders x 2 x n_time): The coordinates of the cylinders in the
+            wind-aligned frame.
+
+        Returns:
+            u_rot (np.ndarray): The x-component of the wind field at the grid points.
+            v_rot (np.ndarray): The y-component of the wind field at the grid points.
+
+        """
+        diff = rotated_grid[:, np.newaxis, :, :] - rotated_cylinders[np.newaxis, :, :, :]
+        radial_distance = np.linalg.norm(diff, axis=2)
+        x_diff = diff[:, :, 0, :]
+        y_diff = diff[:, :, 1, :]
+        radius_squared = self.site_layout.cylinder_radius.T**2
+        radial_distance_sq = radial_distance**2
+        radial_distance_quad = radial_distance_sq**2
+        radial_distance_quad[radial_distance_quad == 0] = np.nan
+        radius_sq_over_r4 = radius_squared[:, :, np.newaxis] / radial_distance_quad
+
+        if grid_coordinates.up is None:
+            sum_term_x = np.einsum("nct, nct->nt", radius_sq_over_r4, (y_diff**2 - x_diff**2))
+            sum_term_y = np.einsum("nct, nct->nt", radius_sq_over_r4, (y_diff * x_diff))
+        else:
+            height_mask = grid_coordinates.up <= self.site_layout.cylinder_coordinates.up.T
+            height_mask = height_mask.reshape(grid_coordinates.nof_observations, self.site_layout.nof_cylinders)
+            sum_term_x = np.einsum("nc, nct, nct->nt", height_mask, radius_sq_over_r4, (y_diff**2 - x_diff**2))
+            sum_term_y = np.einsum("nc, nct, nct->nt", height_mask, radius_sq_over_r4, (y_diff * x_diff))
+        wind_speed = np.sqrt(u**2 + v**2).T
+        u_rot = wind_speed * (1 + sum_term_x)
+        v_rot = -2 * wind_speed * sum_term_y
+        u_rot[self.site_layout.id_obstacles.flatten(), :] = 0
+        v_rot[self.site_layout.id_obstacles.flatten(), :] = 0
+        return u_rot, v_rot

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
@@ -26,7 +27,7 @@ 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.meteorology.meteorology import Meteorology, MeteorologyGroup
 from pyelq.plotting.plot import Plot
 from pyelq.sensor.sensor import SensorGroup
 

pyelq/plotting/__init__.py

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

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

pyelq/preprocessing.py

@@ -1,17 +1,16 @@
 # SPDX-FileCopyrightText: 2024 Shell Global Solutions International B.V. All Rights Reserved.
 #
 # SPDX-License-Identifier: Apache-2.0
-
 """Class for performing preprocessing on the loaded data."""
 
 from copy import deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Union
 
 import numpy as np
 import pandas as pd
 
-from pyelq.meteorology import Meteorology, MeteorologyGroup
+from pyelq.meteorology.meteorology import Meteorology, MeteorologyGroup
 from pyelq.sensor.sensor import Sensor, SensorGroup
 from pyelq.support_functions.spatio_temporal_interpolation import temporal_resampling
 
@@ -21,16 +20,17 @@ class Preprocessor:
     """Class which implements generic functionality for pre-processing of sensor and meteorology information.
 
     Attributes:
-        time_bin_edges (pd.arrays.DatetimeArray): edges of the time bins to be used for smoothing/interpolation.
+        time_bin_edges (Union[pd.arrays.DatetimeArray, None]): edges of the time bins to be used for
+        smoothing/interpolation. If None, no smoothing/interpolation is performed.
         sensor_object (SensorGroup): sensor group object containing raw data.
         met_object (Meteorology): met object containing raw data.
         aggregate_function (str): function to be used for aggregation of data. Defaults to mean.
         sensor_fields (list): standard list of sensor attributes that we wish to regularize and/or filter.
         met_fields (list): standard list of meteorology attributes that we wish to regularize/filter.
-
+        is_regularized (bool): flag indicating whether the met and sensor data has been regularized.
     """
 
-    time_bin_edges: pd.arrays.DatetimeArray
+    time_bin_edges: Union[pd.arrays.DatetimeArray, None]
     sensor_object: SensorGroup
     met_object: Union[Meteorology, MeteorologyGroup]
     aggregate_function: str = "mean"
@@ -47,27 +47,36 @@ class Preprocessor:
         "wind_turbulence_horizontal",
         "wind_turbulence_vertical",
     ]
+    is_regularized: bool = field(init=False, default=False)
 
     def __post_init__(self) -> None:
         """Initialise the class.
 
         Attaching the sensor and meteorology objects as attributes, and running initial regularization and NaN filtering
-        steps.
+        steps. If time_bin_edges is provided, the data will be smoothed/interpolated onto the specified time grid and
+        NaN values will be filtered out. If time_bin_edges is None, the data will be filtered for NaN values only.
 
-        Before running the regularization & NaN filtering, the function ensures that u_component and v_component are
-        present as fields on met_object. The post-smoothing wind speed and direction are then calculated from the
-        smoothed u and v components, to eliminate the need to take means of directions when binning.
+        Before running the regularization (for the case where time_bin_edges is provided) & NaN filtering, the function
+        ensures that u_component and v_component are present as fields on met_object. The post-smoothing wind speed and
+        direction are then calculated from the smoothed u and v components, to eliminate the need to take means of
+        directions when binning.
 
-        The sensor and meteorology group objects attached to the class will have identical numbers of data points per
-        device, identical time stamps, and be free of NaNs.
+        If time_bin_edges is provided, the sensor and meteorology group objects attached to the class will have
+        identical numbers of data points per device, identical time stamps, and be free of NaNs. If time_bin_edges is
+        None, the sensor and meteorology group objects will not have identical time stamps, but will be free of NaNs.
+        The time stamps for the sensor objects and meteorology objects will be the original time stamps.
 
         """
         self.met_object.calculate_uv_from_wind_speed_direction()
+        if self.time_bin_edges is not None:
+            self.regularize_data()
 
-        self.regularize_data()
         self.met_object.calculate_wind_direction_from_uv()
         self.met_object.calculate_wind_speed_from_uv()
-        self.filter_nans()
+        if self.is_regularized:
+            self.filter_nans()
+        else:
+            self.filter_nans_no_regularize()
 
     def regularize_data(self) -> None:
         """Smoothing or interpolation of data onto a common set of time points.
@@ -88,6 +97,7 @@ class Preprocessor:
         will have identical time stamps, but may still contain NaNs.
 
         """
+        self.is_regularized = True
         sensor_out = deepcopy(self.sensor_object)
         for sns_new, sns_old in zip(sensor_out.values(), self.sensor_object.values()):
             for field in self.sensor_fields:
@@ -126,23 +136,66 @@ class Preprocessor:
         for sns_key, met_key in zip(self.sensor_object, self.met_object):
             sns_in = self.sensor_object[sns_key]
             met_in = self.met_object[met_key]
-            filter_index = np.ones(sns_in.nof_observations, dtype=bool)
-            for field in self.sensor_fields:
-                if (field != "time") and (getattr(sns_in, field) is not None):
-                    filter_index = np.logical_and(filter_index, np.logical_not(np.isnan(getattr(sns_in, field))))
-            for field in self.met_fields:
-                if (field != "time") and (getattr(met_in, field) is not None):
-                    filter_index = np.logical_and(filter_index, np.logical_not(np.isnan(getattr(met_in, field))))
+
+            filter_index_sensor = self.get_nan_filter_index(sns_in, self.sensor_fields)
+            filter_index_met = self.get_nan_filter_index(met_in, self.met_fields)
+            filter_index = np.logical_and(filter_index_sensor, filter_index_met)
 
             self.sensor_object[sns_key] = self.filter_object_fields(sns_in, self.sensor_fields, filter_index)
             self.met_object[met_key] = self.filter_object_fields(met_in, self.met_fields, filter_index)
 
+    def filter_nans_no_regularize(self) -> None:
+        """Filter out data points where any of the specified sensor or meteorology fields has a NaN value.
+
+        Function first works through all sensor and meteorology fields and finds indices of all times where there is a
+        NaN value in any field. Then, it uses the resulting index to filter all fields.
+        The sensor_object and met_object are not assumed to have the same time stamps and they are treated separately.
+
+        The result of this function is that the sensor_object and met_object attributes of the class are updated, any
+        NaN values having been removed.
+
+        """
+        for sns_key in self.sensor_object:
+            sns_in = self.sensor_object[sns_key]
+            filter_index = self.get_nan_filter_index(sns_in, self.sensor_fields)
+            self.sensor_object[sns_key] = self.filter_object_fields(sns_in, self.sensor_fields, filter_index)
+
+        if isinstance(self.met_object, Meteorology):
+            filter_index = self.get_nan_filter_index(self.met_object, self.met_fields)
+            self.met_object = self.filter_object_fields(self.met_object, self.met_fields, filter_index)
+        else:
+            raise TypeError("MeteorologyGroup not required in case with no regularization.")
+
+    @staticmethod
+    def get_nan_filter_index(obj: Union[Sensor, Meteorology], field_list: list) -> np.ndarray:
+        """Get a index for a given object to be able to filter out on NaN values in listed fields.
+
+        Args:
+            obj: Sensor or Meteorology object.
+            field_list (list): list of field names to be checked for NaN values.
+
+        Returns:
+            filter_index (np.ndarray): boolean array indicating which indices do not have NaN values in
+                any of the specified fields.
+
+        """
+        filter_index = np.ones(obj.nof_observations, dtype=bool)
+
+        for field_name in field_list:
+            if (field_name != "time") and (getattr(obj, field_name) is not None):
+                filter_index = np.logical_and(filter_index, np.logical_not(np.isnan(getattr(obj, field_name))))
+
+        return filter_index
+
     def filter_on_met(self, filter_variable: list, lower_limit: list = None, upper_limit: list = None) -> None:
         """Filter the supplied data on given properties of the meteorological data.
 
-        Assumes that the SensorGroup and MeteorologyGroup objects attached as attributes have corresponding values (one
-        per sensor device), and have attributes that have been pre-smoothed/interpolated onto a common time grid per
-        device.
+        If self.is_regularized, the filtering is done on both sensor_object and met_object and assumes that the
+        SensorGroup and MeteorologyGroup objects attached as attributes have corresponding values (one per sensor
+        device), and have attributes that have been pre-smoothed/interpolated onto a common time grid per device.
+
+        If the data is not regularized, the filtering is done on the met_object only. In this case a MeteorologyGroup
+        is not allowed.
 
         The result of this function is that the sensor_object and met_object attributes are updated with the filtered
         versions.
@@ -160,13 +213,20 @@ class Preprocessor:
         if upper_limit is None:
             upper_limit = [np.inf] * len(filter_variable)
 
-        for vrb, low, high in zip(filter_variable, lower_limit, upper_limit):
-            for sns_key, met_key in zip(self.sensor_object, self.met_object):
-                sns_in = self.sensor_object[sns_key]
-                met_in = self.met_object[met_key]
-                index_keep = np.logical_and(getattr(met_in, vrb) >= low, getattr(met_in, vrb) <= high)
-                self.sensor_object[sns_key] = self.filter_object_fields(sns_in, self.sensor_fields, index_keep)
-                self.met_object[met_key] = self.filter_object_fields(met_in, self.met_fields, index_keep)
+        if self.is_regularized:
+            for vrb, low, high in zip(filter_variable, lower_limit, upper_limit):
+                for sns_key, met_key in zip(self.sensor_object, self.met_object):
+                    sns_in = self.sensor_object[sns_key]
+                    met_in = self.met_object[met_key]
+                    index_keep = np.logical_and(getattr(met_in, vrb) >= low, getattr(met_in, vrb) <= high)
+                    self.sensor_object[sns_key] = self.filter_object_fields(sns_in, self.sensor_fields, index_keep)
+                    self.met_object[met_key] = self.filter_object_fields(met_in, self.met_fields, index_keep)
+        else:
+            if isinstance(self.met_object, MeteorologyGroup):
+                raise TypeError("MeteorologyGroup not required in case with no regularization.")
+            for vrb, low, high in zip(filter_variable, lower_limit, upper_limit):
+                index_keep = np.logical_and(getattr(self.met_object, vrb) >= low, getattr(self.met_object, vrb) <= high)
+                self.met_object = self.filter_object_fields(self.met_object, self.met_fields, index_keep)
 
     def block_data(
         self, time_edges: pd.arrays.DatetimeArray, data_object: Union[SensorGroup, MeteorologyGroup]
@@ -229,9 +289,9 @@ class Preprocessor:
 
         """
         return_object = deepcopy(data_object)
-        for field in fields:
-            if getattr(return_object, field) is not None:
-                setattr(return_object, field, getattr(return_object, field)[index])
+        for field_name in fields:
+            if getattr(return_object, field_name) is not None:
+                setattr(return_object, field_name, getattr(return_object, field_name)[index])
         return return_object
 
     def interpolate_single_met_object(self, met_in_object: Meteorology) -> Meteorology:
@@ -246,15 +306,15 @@ class Preprocessor:
         """
         met_out_object = Meteorology()
         time_out = None
-        for field in self.met_fields:
-            if (field != "time") and (getattr(met_in_object, field) is not None):
+        for field_name in self.met_fields:
+            if (field_name != "time") and (getattr(met_in_object, field_name) is not None):
                 time_out, resampled_values = temporal_resampling(
                     met_in_object.time,
-                    getattr(met_in_object, field),
+                    getattr(met_in_object, field_name),
                     self.time_bin_edges,
                     self.aggregate_function,
                 )
-                setattr(met_out_object, field, resampled_values)
+                setattr(met_out_object, field_name, resampled_values)
 
         if time_out is not None:
             met_out_object.time = time_out

pyelq/sensor/__init__.py

@@ -2,4 +2,5 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 """Sensor Module."""
+
 __all__ = ["satellite", "beam", "sensor"]

pyelq/sensor/sensor.py

@@ -107,6 +107,44 @@ class Sensor:
 
         return fig
 
+    def subset_sensor(self, section_index: int) -> "Sensor":
+        """Subset the sensor based on the provided section index.
+
+        The method is designed to return a new `Sensor` object containing only the observations corresponding to a
+        specified section index. Sections are defined by unique values in the `source_on` attribute. For a case where
+        the source is turned on and off multiple times, (0 values in `source_on` indicate off periods and positive
+        integers indicate different on periods). For example, if section_index=1, a new Sensor will be returned
+        containing only observations where self.source_on == 1.
+
+        If sensor.location.shape[0] and sensor.time.shape[0] align we assume the location values are dependent on time and
+        therefore need to be filtered accordingly and otherwise we keep the original location.
+
+        This functionality is useful for situations where data is collected in multiple sections, e.g. repeated on/off
+        releases where we want to work with one section at a time or later stitch multiple per-section segments
+        together.
+
+        Args:
+            section_index (int): Integer indicating which observations to keep.
+
+        Returns:
+            new_sensor (Sensor): A new Sensor object containing only the specified observations.
+
+        """
+        if self.source_on is None:
+            return deepcopy(self)
+
+        section_indices = (self.source_on == section_index).flatten()
+        new_sensor = deepcopy(self)
+        new_sensor.time = self.time[section_indices]
+        new_sensor.concentration = self.concentration[section_indices]
+        location_object = new_sensor.location.to_array()
+        if location_object.shape[0] == self.time.shape[0]:
+            location_object = location_object[section_indices, :]
+            new_sensor.location = new_sensor.location.from_array(location_object)
+
+        new_sensor.source_on = self.source_on[section_indices]
+        return new_sensor
+
 
 @dataclass
 class SensorGroup(dict):
@@ -170,7 +208,9 @@ class SensorGroup(dict):
 
     @property
     def source_on(self) -> np.ndarray:
-        """Column vector of booleans indicating whether sources are expected to be on, unwrapped over sensors.
+        """Column vector of integers indicating whether sources are expected to be on, unwrapped over sensors.
+
+        Different integer values represent different sections where the source is on.
 
         Assumes source is on when None is specified for a specific sensor.
 
@@ -179,14 +219,14 @@ class SensorGroup(dict):
 
         """
         overall_idx = np.array([])
-        for curr_key in list(self.keys()):
+        for curr_key in self.keys():
             if self[curr_key].source_on is None:
-                temp_idx = np.ones(self[curr_key].nof_observations).astype(bool)
+                temp_idx = np.ones(self[curr_key].nof_observations).astype(int)
             else:
-                temp_idx = self[curr_key].source_on
+                temp_idx = self[curr_key].source_on.flatten()
 
             overall_idx = np.concatenate([overall_idx, temp_idx])
-        return overall_idx.astype(bool)
+        return overall_idx.astype(int)
 
     @property
     def nof_sensors(self) -> int:
@@ -239,3 +279,28 @@ class SensorGroup(dict):
             fig = sensor.plot_timeseries(fig, color=color_map[color_idx], mode=mode)
 
         return fig
+
+    def subset_sensor(self, section_index: int) -> "SensorGroup":
+        """Subset the sensor based on the provided section index.
+
+        The method is designed to return a new `SensorGroup` object containing only the observations corresponding to a
+        specified section index. Sections are defined by unique values in the `sensor.source_on` attribute. For a case
+        where the source is turned on and off multiple times, (0 values in `sensor.source_on` indicate off periods and
+        positive integers indicate different on periods). For example, if section_index=1, a new SensorGroup will be
+        returned containing only observations where sensor.source_on == 1.
+        This functionality is useful for situations where data is collected in multiple sections, e.g. repeated on/off
+        releases where we want to work with one section at a time or later stitch multiple per-section segments
+        together.
+
+        Args:
+            section_index (int): An integer indicating which observations to keep.
+
+        Returns:
+            SensorGroup: A new SensorGroup object containing only the specified observations
+
+        """
+        subset_sensor = SensorGroup()
+        for _, sensor in enumerate(self.values()):
+            subset_sensor_i = sensor.subset_sensor(section_index)
+            subset_sensor.add_sensor(subset_sensor_i)
+        return subset_sensor

pyelq/source_map.py

@@ -8,6 +8,7 @@
 The class for the source maps used in pyELQ
 
 """
+
 from dataclasses import dataclass, field
 from typing import Union
 

pyelq/support_functions/__init__.py

@@ -2,4 +2,5 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 """Support Functions Module."""
+
 __all__ = ["post_processing", "spatio_temporal_interpolation"]

pyelq/support_functions/post_processing.py

@@ -8,6 +8,7 @@
 Module containing some functions used in post-processing of the results.
 
 """
+
 import warnings
 from typing import TYPE_CHECKING, Tuple, Union
 

pyelq/support_functions/spatio_temporal_interpolation.py

@@ -8,6 +8,7 @@
 Support function to perform interpolation in various ways
 
 """
+
 import warnings
 from typing import Tuple, Union