ocf-data-sampler 0.5.9__py3-none-any.whl → 0.5.10__py3-none-any.whl

ocf_data_sampler/select/geospatial.py

@@ -1,7 +1,6 @@
 """Geospatial coordinate transformation functions.
 
 Provides utilities for working with different coordinate systems
-commonly used in geospatial applications, particularly for UK-based data.
 
 Supports conversions between:
 - OSGB36 (Ordnance Survey Great Britain, easting/northing in meters)
@@ -11,159 +10,198 @@ Supports conversions between:
 
 import numpy as np
 import pyproj
-import pyresample
 import xarray as xr
+from pyresample.area_config import load_area_from_string
 
 # Coordinate Reference System (CRS) identifiers
-# OSGB36: UK Ordnance Survey National Grid (easting/northing in meters)
-# Refer to - https://epsg.io/27700
-OSGB36 = 27700
 
-# WGS84: World Geodetic System 1984 (latitude/longitude in degrees), used in GPS
+# OSGB36: UK Ordnance Survey National Grid (easting/northing in meters) - https://epsg.io/27700
+OSGB36 = 27700
+# WGS84: World Geodetic System 1984 (latitude/longitude in degrees) - https://epsg.io/4326
 WGS84 = 4326
 
-# Pre-init Transformer
-_osgb_to_lon_lat = pyproj.Transformer.from_crs(
-    crs_from=OSGB36,
-    crs_to=WGS84,
-    always_xy=True,
-).transform
-_lon_lat_to_osgb = pyproj.Transformer.from_crs(
-    crs_from=WGS84,
-    crs_to=OSGB36,
-    always_xy=True,
-).transform
+# Pre-inititiate coordinate Transformer objects
+_osgb_to_lon_lat = pyproj.Transformer.from_crs(crs_from=OSGB36, crs_to=WGS84, always_xy=True)
+_lon_lat_to_osgb = pyproj.Transformer.from_crs(crs_from=WGS84, crs_to=OSGB36, always_xy=True)
 
 
 def osgb_to_lon_lat(
     x: float | np.ndarray,
     y: float | np.ndarray,
 ) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Change OSGB coordinates to lon-lat.
+    """Convert OSGB coordinates to lon-lat.
 
     Args:
         x: osgb east-west
-        y: osgb north-south
-    Return: 2-tuple of longitude (east-west), latitude (north-south)
+        y: osgb south-north
+
+    Return: longitude, latitude
     """
-    return _osgb_to_lon_lat(xx=x, yy=y)
+    return _osgb_to_lon_lat.transform(xx=x, yy=y)
 
 
 def lon_lat_to_osgb(
     x: float | np.ndarray,
     y: float | np.ndarray,
 ) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Change lon-lat coordinates to OSGB.
+    """Convert lon-lat coordinates to OSGB.
 
     Args:
         x: longitude east-west
-        y: latitude north-south
+        y: latitude south-north
 
-    Return: 2-tuple of OSGB x, y
+    Return: x_osgb, y_osgb
     """
-    return _lon_lat_to_osgb(xx=x, yy=y)
+    return _lon_lat_to_osgb.transform(xx=x, yy=y)
+
+
+def _get_geostationary_coord_transform(
+    crs_from: int,
+    area_string: str,
+) -> pyproj.transformer.Transformer:
+    """Loads geostationary area and transforms to geostationary coords.
+
+    Args:
+        x: osgb east-west, or latitude
+        y: osgb south-north, or longitude
+        crs_from: the cordiates system of x, y
+        area_string: String containing yaml geostationary area definition to convert to.
+
+    Returns: Coordinate Transformer
+    """
+    if crs_from not in [OSGB36, WGS84]:
+        raise ValueError(f"Unrecognized coordinate system: {crs_from}")
+
+    geostationary_crs = load_area_from_string(area_string).crs
+
+    return pyproj.Transformer.from_crs(
+        crs_from=crs_from,
+        crs_to=geostationary_crs,
+        always_xy=True,
+    )
 
 
 def lon_lat_to_geostationary_area_coords(
     longitude: float | np.ndarray,
     latitude: float | np.ndarray,
-    xr_data: xr.DataArray,
+    area_string: str,
 ) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Loads geostationary area and transformation from lat-lon to geostationary coords.
+    """Convert from lon-lat to geostationary coords.
 
     Args:
         longitude: longitude
         latitude: latitude
-        xr_data: xarray object with geostationary area
+        area_string: String containing yaml geostationary area definition to convert to.
 
-    Returns:
-        Geostationary coords: x, y
+    Returns: x_geostationary, y_geostationary
     """
-    return coordinates_to_geostationary_area_coords(longitude, latitude, xr_data, WGS84)
+    coord_transformer = _get_geostationary_coord_transform(WGS84, area_string)
+    return coord_transformer.transform(xx=longitude, yy=latitude)
 
 
 def osgb_to_geostationary_area_coords(
     x: float | np.ndarray,
     y: float | np.ndarray,
-    xr_data: xr.DataArray,
+    area_string: str,
 ) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Loads geostationary area and transformation from OSGB to geostationary coords.
+    """Convert from OSGB to geostationary coords.
 
     Args:
         x: osgb east-west
-        y: osgb north-south
-        xr_data: xarray object with geostationary area
+        y: osgb south-north
+        area_string: String containing yaml geostationary area definition to convert to.
+
+    Returns: x_geostationary, y_geostationary
+    """
+    coord_transformer = _get_geostationary_coord_transform(OSGB36, area_string)
+    return coord_transformer.transform(xx=x, yy=y)
+
+
+def find_coord_system(da: xr.DataArray) -> tuple[str, str, str]:
+    """Searches the Xarray object to determine the spatial coordinate system.
+
+    Args:
+        da: Dataset with spatial coords
 
     Returns:
-        Geostationary coords: x, y
+        Three strings with:
+            1. The kind of the coordinate system
+            2. Name of the x-coordinate
+            3. Name of the y-coordinate
     """
-    return coordinates_to_geostationary_area_coords(x, y, xr_data, OSGB36)
+    # We only look at the dimensional coords. It is possible that other coordinate systems are
+    # included as non-dimensional coords
+    dimensional_coords = set(da.xindexes)
+
+    coord_systems = {
+        "lon_lat": ["longitude", "latitude"],
+        "geostationary": ["x_geostationary", "y_geostationary"],
+        "osgb": ["x_osgb", "y_osgb"],
+    }
+
+    coords_systems_found = []
+
+    for coord_name, coord_set in coord_systems.items():
+        if set(coord_set) <= dimensional_coords:
+            coords_systems_found.append(coord_name)
+
+    if len(coords_systems_found)==0:
+        raise ValueError(
+            f"Did not find any coordinate pairs in the dimensional coords: {dimensional_coords}",
+        )
+    elif len(coords_systems_found)>1:
+        raise ValueError(
+            f"Found >1 ({coords_systems_found}) coordinate pairs in the dimensional coords: "
+            f"{dimensional_coords}",
+        )
+    else:
+        coord_system_name = coords_systems_found[0]
+        return coord_system_name, *coord_systems[coord_system_name]
 
 
-def coordinates_to_geostationary_area_coords(
+def convert_coordinates(
     x: float | np.ndarray,
     y: float | np.ndarray,
-    xr_data: xr.DataArray,
-    crs_from: int,
+    from_coords: str,
+    target_coords: str,
+    area_string: str | None = None,
 ) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Loads geostationary area and transforms to geostationary coords.
+    """Convert x and y coordinates from one coordinate system to another.
 
     Args:
-        x: osgb east-west, or latitude
-        y: osgb north-south, or longitude
-        xr_data: xarray object with geostationary area
-        crs_from: the cordiates system of x,y
+        x: The x-coordinate to convert.
+        y: The y-coordinate to convert.
+        from_coords: The coordinate system to convert from.
+        target_coords: The coordinate system to convert to
+        area_string: Optional string containing yaml geostationary area definition. Only used if
+            from_coords or target_coords is "geostationary"
 
     Returns:
-        Geostationary coords: x, y
+        The converted (x, y) coordinates.
     """
-    if crs_from not in [OSGB36, WGS84]:
-        raise ValueError(f"Unrecognized coordinate system: {crs_from}")
+    if from_coords==target_coords:
+        return x, y
 
-    area_definition_yaml = xr_data.attrs["area"]
+    if "geostationary" in (from_coords, target_coords) and area_string is not None:
+        ValueError("If using geostationary coords the `area_string` must be provided")
 
-    geostationary_area_definition = pyresample.area_config.load_area_from_string(
-        area_definition_yaml,
-    )
-    geostationary_crs = geostationary_area_definition.crs
-    osgb_to_geostationary = pyproj.Transformer.from_crs(
-        crs_from=crs_from,
-        crs_to=geostationary_crs,
-        always_xy=True,
-    ).transform
-    return osgb_to_geostationary(xx=x, yy=y)
-
-
-def _coord_priority(available_coords: list[str]) -> tuple[str, str, str]:
-    """Determines the coordinate system of spatial coordinates present."""
-    if "longitude" in available_coords:
-        return "lon_lat", "longitude", "latitude"
-    elif "x_geostationary" in available_coords:
-        return "geostationary", "x_geostationary", "y_geostationary"
-    elif "x_osgb" in available_coords:
-        return "osgb", "x_osgb", "y_osgb"
-    else:
-        raise ValueError(f"Unrecognized coordinate system: {available_coords}")
+    match (from_coords, target_coords):
 
+        case ("osgb", "geostationary"):
+            x, y = osgb_to_geostationary_area_coords(x, y, area_string)
 
-def spatial_coord_type(ds: xr.DataArray) -> tuple[str, str, str]:
-    """Searches the data array to determine the kind of spatial coordinates present.
+        case ("lon_lat", "geostationary"):
+            x, y = lon_lat_to_geostationary_area_coords(x, y, area_string)
 
-    This search has a preference for the dimension coordinates of the xarray object.
+        case ("osgb", "lon_lat"):
+            x, y = osgb_to_lon_lat(x, y)
 
-    Args:
-        ds: Dataset with spatial coords
-
-    Returns:
-        Three strings with:
-            1. The kind of the coordinate system
-            2. Name of the x-coordinate
-            3. Name of the y-coordinate
-    """
-    if isinstance(ds, xr.DataArray):
-        # Search dimension coords of dataarray
-        coords = _coord_priority(ds.xindexes)
-    else:
-        raise ValueError(f"Unrecognized input type: {type(ds)}")
+        case ("lon_lat", "osgb"):
+            x, y = lon_lat_to_osgb(x, y)
 
-    return coords
+        case (_, _):
+            raise NotImplementedError(
+                f"Conversion from {from_coords} to "
+                f"{target_coords} is not supported",
+            )
+    return x, y

ocf_data_sampler/select/location.py

@@ -1,27 +1,63 @@
-"""Location model with coordinate system validation."""
+"""Location object."""
 
-from pydantic import BaseModel, Field, model_validator
 
-allowed_coordinate_systems = ["osgb", "lon_lat", "geostationary", "idx"]
+allowed_coord_systems = {"osgb", "lon_lat", "geostationary"}
 
 
-class Location(BaseModel):
-    """Represent a spatial location."""
+class Location:
+    """A spatial location."""
 
-    coordinate_system: str = Field(...,
-        description="Coordinate system for the location must be lon_lat, osgb, or geostationary",
-    )
+    def __init__(self, x: float, y: float, coord_system: int, id: int | str | None = None) -> None:
+        """A spatial location.
 
-    x: float = Field(..., description="x coordinate - i.e. east-west position")
-    y: float = Field(..., description="y coordinate - i.e. north-south position")
-    id: int | None = Field(None, description="ID of the location - e.g. GSP ID")
+        Args:
+            x: The east-west / left-right location
+            y: The south-north / down-up location
+            coord_system: The coordinate system
+            id: The location ID
+        """
+        self._check_valid_coord_system(coord_system)
+        self._projections: dict[str, tuple[float, float]] = {coord_system: (x, y)}
+        self.id = id
 
-    @model_validator(mode="after")
-    def validate_coordinate_system(self) -> "Location":
-        """Validate 'coordinate_system'."""
-        if self.coordinate_system not in allowed_coordinate_systems:
+    @staticmethod
+    def _check_valid_coord_system(coord_system: str) -> None:
+        if coord_system not in allowed_coord_systems:
+            raise ValueError(f"Coordinate  {coord_system} is not supported")
+
+    def in_coord_system(self, coord_system: str) -> tuple[float, float]:
+        """Get the location in a specified coordinate system.
+
+        Args:
+            coord_system: The desired output coordinate system
+        """
+        self._check_valid_coord_system(coord_system)
+
+        if coord_system in self._projections:
+            return self._projections[coord_system]
+        else:
             raise ValueError(
-                f"coordinate_system = {self.coordinate_system} "
-                f"is not in {allowed_coordinate_systems}",
+                "Requested the coodinate in {coord_system}. This has not yet been added. "
+                "The current available coordinate systems are "
+                f"{list(self.self._projections.keys())}",
             )
-        return self
+
+    def add_coord_system(self, x: float, y: float, coord_system: int) -> None:
+        """Add the equivalent location in a different coordinate system.
+
+        Args:
+            x: The east-west / left-right coordinate
+            y: The south-north / down-up coordinate
+            coord_system: The coordinate system name
+        """
+        self._check_valid_coord_system(coord_system)
+        if coord_system in self._projections:
+            if not (x, y)==self._projections[coord_system]:
+                raise ValueError(
+                    f"Tried to re-add coordinate projection {coord_system}, but the supplied"
+                    f"coodrinate values ({x}, {y}) do not match the already stored values "
+                    f"{self._projections[coord_system]}",
+                )
+        else:
+            self._projections[coord_system] = (x, y)
+

ocf_data_sampler/select/select_spatial_slice.py

@@ -1,63 +1,13 @@
 """Select spatial slices."""
 
-import logging
-
 import numpy as np
 import xarray as xr
 
-from ocf_data_sampler.select.geospatial import (
-    lon_lat_to_geostationary_area_coords,
-    lon_lat_to_osgb,
-    osgb_to_geostationary_area_coords,
-    osgb_to_lon_lat,
-    spatial_coord_type,
-)
+from ocf_data_sampler.select.geospatial import find_coord_system
 from ocf_data_sampler.select.location import Location
 
-logger = logging.getLogger(__name__)
-
-
-def convert_coordinates(
-    from_coords: str,
-    x: float | np.ndarray,
-    y: float | np.ndarray,
-    da: xr.DataArray,
-) -> tuple[float | np.ndarray, float | np.ndarray]:
-    """Convert x and y coordinates to coordinate system matching xarray data.
-
-    Args:
-        from_coords: The coordinate system to convert from.
-        x: The x-coordinate to convert.
-        y: The y-coordinate to convert.
-        da: The xarray DataArray used for context (e.g., for geostationary conversion).
-
-    Returns:
-        The converted (x, y) coordinates.
-    """
-    target_coords, *_ = spatial_coord_type(da)
-
-    match (from_coords, target_coords):
-        case ("osgb", "geostationary"):
-            x, y = osgb_to_geostationary_area_coords(x, y, da)
-        case ("osgb", "lon_lat"):
-            x, y = osgb_to_lon_lat(x, y)
-        case ("osgb", "osgb"):
-            pass
-        case ("lon_lat", "osgb"):
-            x, y = lon_lat_to_osgb(x, y)
-        case ("lon_lat", "geostationary"):
-            x, y = lon_lat_to_geostationary_area_coords(x, y, da)
-        case ("lon_lat", "lon_lat"):
-            pass
-        case (_, _):
-            raise NotImplementedError(
-                f"Conversion from {from_coords} to "
-                f"{target_coords} is not supported",
-            )
-    return x, y
-
 
-def _get_pixel_index_location(da: xr.DataArray, location: Location) -> Location:
+def _get_pixel_index_location(da: xr.DataArray, location: Location) -> tuple[int, int]:
     """Find pixel index location closest to given Location.
 
     Args:
@@ -65,14 +15,14 @@ def _get_pixel_index_location(da: xr.DataArray, location: Location) -> Location:
         location: The Location object representing the point of interest.
 
     Returns:
-        A Location object with x and y attributes representing the pixel indices.
+        The pixel indices.
 
     Raises:
         ValueError: If the location is outside the bounds of the DataArray.
     """
-    xr_coords, x_dim, y_dim = spatial_coord_type(da)
+    target_coords, x_dim, y_dim = find_coord_system(da)
 
-    x, y = convert_coordinates(location.coordinate_system, location.x, location.y, da)
+    x, y = location.in_coord_system(target_coords)
 
     # Check that requested point lies within the data
     if not (da[x_dim].min() < x < da[x_dim].max()):
@@ -89,7 +39,7 @@ def _get_pixel_index_location(da: xr.DataArray, location: Location) -> Location:
     closest_x = x_index.get_indexer([x], method="nearest")[0]
     closest_y = y_index.get_indexer([y], method="nearest")[0]
 
-    return Location(x=closest_x, y=closest_y, coordinate_system="idx")
+    return closest_x, closest_y
 
 
 def _select_padded_slice(
@@ -213,16 +163,16 @@ def select_spatial_slice_pixels(
     if (height_pixels % 2) != 0:
         raise ValueError("Height must be an even number")
 
-    _, x_dim, y_dim = spatial_coord_type(da)
-    center_idx = _get_pixel_index_location(da, location)
+    _, x_dim, y_dim = find_coord_system(da)
+    center_idx_x, center_idx_y = _get_pixel_index_location(da, location)
 
     half_width = width_pixels // 2
     half_height = height_pixels // 2
 
-    left_idx = int(center_idx.x - half_width)
-    right_idx = int(center_idx.x + half_width)
-    bottom_idx = int(center_idx.y - half_height)
-    top_idx = int(center_idx.y + half_height)
+    left_idx = int(center_idx_x - half_width)
+    right_idx = int(center_idx_x + half_width)
+    bottom_idx = int(center_idx_y - half_height)
+    top_idx = int(center_idx_y + half_height)
 
     data_width_pixels = len(da[x_dim])
     data_height_pixels = len(da[y_dim])

ocf_data_sampler/torch_datasets/datasets/pvnet_uk.py

@@ -19,17 +19,15 @@ from ocf_data_sampler.numpy_sample.common_types import NumpyBatch, NumpySample
 from ocf_data_sampler.numpy_sample.gsp import GSPSampleKey
 from ocf_data_sampler.numpy_sample.nwp import NWPSampleKey
 from ocf_data_sampler.select import Location, fill_time_periods
-from ocf_data_sampler.select.geospatial import osgb_to_lon_lat
 from ocf_data_sampler.torch_datasets.utils import (
+    add_alterate_coordinate_projections,
     config_normalization_values_to_dicts,
+    fill_nans_in_arrays,
     find_valid_time_periods,
+    merge_dicts,
     slice_datasets_by_space,
     slice_datasets_by_time,
 )
-from ocf_data_sampler.torch_datasets.utils.merge_and_fill_utils import (
-    fill_nans_in_arrays,
-    merge_dicts,
-)
 from ocf_data_sampler.utils import minutes, tensorstore_compute
 
 xr.set_options(keep_attrs=True)
@@ -59,10 +57,10 @@ def get_gsp_locations(
     for gsp_id in gsp_ids:
         locations.append(
             Location(
-                coordinate_system="osgb",
                 x=df_gsp_loc.loc[gsp_id].x_osgb,
                 y=df_gsp_loc.loc[gsp_id].y_osgb,
-                id=gsp_id,
+                coord_system="osgb",
+                id=int(gsp_id),
             ),
         )
     return locations
@@ -100,10 +98,13 @@ class AbstractPVNetUKDataset(Dataset):
             valid_t0_times = valid_t0_times[valid_t0_times <= pd.Timestamp(end_time)]
 
         # Construct list of locations to sample from
-        self.locations = get_gsp_locations(
-            gsp_ids,
-            version=config.input_data.gsp.boundaries_version,
+        locations = get_gsp_locations(gsp_ids, version=config.input_data.gsp.boundaries_version)
+        self.locations = add_alterate_coordinate_projections(
+            locations,
+            datasets_dict,
+            primary_coords="osgb",
         )
+
         self.valid_t0_times = valid_t0_times
 
         # Assign config and input data to self
@@ -171,11 +172,14 @@ class AbstractPVNetUKDataset(Dataset):
             )
 
         # Add GSP location data
+
+        osgb_x, osgb_y = location.in_coord_system("osgb")
+
         numpy_modalities.append(
             {
                 GSPSampleKey.gsp_id: location.id,
-                GSPSampleKey.x_osgb: location.x,
-                GSPSampleKey.y_osgb: location.y,
+                GSPSampleKey.x_osgb: osgb_x,
+                GSPSampleKey.y_osgb: osgb_y,
             },
         )
 
@@ -191,7 +195,7 @@ class AbstractPVNetUKDataset(Dataset):
             )
 
             # Convert OSGB coordinates to lon/lat
-            lon, lat = osgb_to_lon_lat(location.x, location.y)
+            lon, lat = location.in_coord_system("lon_lat")
 
             # Calculate solar positions and add to modalities
             numpy_modalities.append(make_sun_position_numpy_sample(datetimes, lon, lat))

ocf_data_sampler/torch_datasets/datasets/site.py

@@ -25,15 +25,14 @@ from ocf_data_sampler.select import (
     intersection_of_multiple_dataframes_of_periods,
 )
 from ocf_data_sampler.torch_datasets.utils import (
+    add_alterate_coordinate_projections,
     config_normalization_values_to_dicts,
+    fill_nans_in_arrays,
     find_valid_time_periods,
+    merge_dicts,
     slice_datasets_by_space,
     slice_datasets_by_time,
 )
-from ocf_data_sampler.torch_datasets.utils.merge_and_fill_utils import (
-    fill_nans_in_arrays,
-    merge_dicts,
-)
 from ocf_data_sampler.utils import minutes, tensorstore_compute
 
 xr.set_options(keep_attrs=True)
@@ -52,7 +51,7 @@ def get_locations(site_xr: xr.Dataset) -> list[Location]:
             id=site_id,
             x=site.longitude.values,
             y=site.latitude.values,
-            coordinate_system="lon_lat",
+            coord_system="lon_lat",
         )
         locations.append(location)
 
@@ -168,8 +167,14 @@ class SitesDataset(Dataset):
         self.datasets_dict = datasets_dict
         self.config = config
 
-        # get all locations
-        self.locations = get_locations(datasets_dict["site"])
+        # Construct list of locations to sample from
+        locations = get_locations(datasets_dict["site"])
+        self.locations = add_alterate_coordinate_projections(
+            locations,
+            datasets_dict,
+            primary_coords="lon_lat",
+        )
+
         self.location_lookup = {loc.id: loc for loc in self.locations}
 
         # Get t0 times where all input data is available

ocf_data_sampler/torch_datasets/utils/__init__.py

@@ -2,4 +2,5 @@ from .config_normalization_values_to_dicts import config_normalization_values_to
 from .merge_and_fill_utils import fill_nans_in_arrays, merge_dicts
 from .valid_time_periods import find_valid_time_periods
 from .spatial_slice_for_dataset import slice_datasets_by_space
-from .time_slice_for_dataset import slice_datasets_by_time
+from .time_slice_for_dataset import slice_datasets_by_time
+from .add_alterate_coordinate_projections import add_alterate_coordinate_projections

ocf_data_sampler/torch_datasets/utils/add_alterate_coordinate_projections.py

@@ -0,0 +1,77 @@
+""""Function for adding more projections to location objects."""
+
+import numpy as np
+
+from ocf_data_sampler.select import Location
+from ocf_data_sampler.select.geospatial import convert_coordinates, find_coord_system
+
+
+def add_alterate_coordinate_projections(
+    locations: list[Location],
+    datasets_dict: dict,
+    primary_coords: str,
+) -> list[Location]:
+    """Add (in-place) coordinate projections for all dataset to a set of locations.
+
+    Args:
+        locations: A list of locations
+        datasets_dict: The dataset dict to add projections for
+        primary_coords: The primary coords of the locations
+
+    Returns:
+        List of locations with all coordinate projections added
+    """
+    if primary_coords not in ["osgb", "lon_lat"]:
+        raise ValueError("Only osbg and lon_lat are currently supported")
+
+    xs, ys = np.array([loc.in_coord_system(primary_coords) for loc in locations]).T
+
+    datasets_list = []
+    if "nwp" in datasets_dict:
+        datasets_list.extend(datasets_dict["nwp"].values())
+    if "sat" in datasets_dict:
+        datasets_list.append(datasets_dict["sat"])
+
+    computed_coord_systems = {primary_coords}
+
+    # Find all the coord systems required by all datasets
+    for da in datasets_list:
+
+        # Fid the dataset required by this dataset
+        coord_system, *_ = find_coord_system(da)
+
+        # Skip if the projections in this coord system have already been computed
+        if coord_system not in computed_coord_systems:
+
+            # If using geostationary coords we need to extract the area definition string
+            area_string = da.attrs["area"] if coord_system=="geostationary" else None
+
+            new_xs, new_ys = convert_coordinates(
+                x=xs,
+                y=ys,
+                from_coords=primary_coords,
+                target_coords=coord_system,
+                area_string=area_string,
+            )
+
+            # Add the projection to the locations objects
+            for x, y, loc in zip(new_xs, new_ys, locations, strict=True):
+                loc.add_coord_system(x, y, coord_system)
+
+            computed_coord_systems.add(coord_system)
+
+    # Add lon-lat to start since it is required to compute the solar coords
+    if "lon_lat" not in computed_coord_systems:
+        new_xs, new_ys = convert_coordinates(
+            x=xs,
+            y=ys,
+            from_coords=primary_coords,
+            target_coords="lon_lat",
+            area_string=None,
+        )
+
+        # Add the projection to the locations objects
+        for x, y, loc in zip(new_xs, new_ys, locations, strict=False):
+            loc.add_coord_system(x, y, "lon_lat")
+
+    return locations

{ocf_data_sampler-0.5.9.dist-info → ocf_data_sampler-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocf-data-sampler
-Version: 0.5.9
+Version: 0.5.10
 Author: James Fulton, Peter Dudfield
 Author-email: Open Climate Fix team <info@openclimatefix.org>
 License: MIT License

{ocf_data_sampler-0.5.9.dist-info → ocf_data_sampler-0.5.10.dist-info}/RECORD

@@ -35,18 +35,19 @@ ocf_data_sampler/select/__init__.py,sha256=mK7Wu_-j9IXGTYrOuDf5yDDuU5a306b0iGKTA
 ocf_data_sampler/select/dropout.py,sha256=BYpv8L771faPOyN7SdIJ5cwkpDve-ohClj95jjsHmjg,1973
 ocf_data_sampler/select/fill_time_periods.py,sha256=TlGxp1xiAqnhdWfLy0pv3FuZc00dtimjWdLzr4JoTGA,865
 ocf_data_sampler/select/find_contiguous_time_periods.py,sha256=etkr6LuB7zxkfzWJ6SgHiULdRuFzFlq5bOUNd257Qx4,11545
-ocf_data_sampler/select/geospatial.py,sha256=CDExkl36eZOKmdJPzUr_K0Wn3axHqv5nYo-EkSiINcc,5032
-ocf_data_sampler/select/location.py,sha256=AZvGR8y62opiW7zACGXjoOtBEWRfSLOZIA73O5Deu0c,1037
-ocf_data_sampler/select/select_spatial_slice.py,sha256=Hd4jGRUfIZRoWCirOQZeoLpaUnStB6KyFSTPX69wZLw,8790
+ocf_data_sampler/select/geospatial.py,sha256=rvMy_e--3tm-KAy9pU6b9-UMBQqH2sXykr3N_4SHYy4,6528
+ocf_data_sampler/select/location.py,sha256=Qp0di-Pgq8WLjN9IBcTVTaRM3lckhr4ZVzaDRcgVXHw,2352
+ocf_data_sampler/select/select_spatial_slice.py,sha256=0nwIRa1Wbmasxgz_PiDvXkNPUaYCdZNaUaOmkV4YIE0,7192
 ocf_data_sampler/select/select_time_slice.py,sha256=HeHbwZ0CP03x0-LaJtpbSdtpLufwVTR73p6wH6O_PS8,5513
 ocf_data_sampler/torch_datasets/datasets/__init__.py,sha256=o0SsEXXZ6k9iL__5_RN1Sf60lw_eqK91P3UFEHAD2k0,102
-ocf_data_sampler/torch_datasets/datasets/pvnet_uk.py,sha256=qbyvTOZZNcGioeH-DDoJmSf_KLRidiuBQRnrvZXD6ts,12046
-ocf_data_sampler/torch_datasets/datasets/site.py,sha256=_FUV_KDe5k7acAmjE9Z2kYgxCFJZrLjziaZssIi1ipg,15465
+ocf_data_sampler/torch_datasets/datasets/pvnet_uk.py,sha256=1uwcbEKakXsqr_ZcSjpzf3esP5tA_YVlYgtj9vBjtdM,12115
+ocf_data_sampler/torch_datasets/datasets/site.py,sha256=Z7pyuR3VHEJf8egxnZvpsdgBv7fMg2pSc61ORAuqOwQ,15607
 ocf_data_sampler/torch_datasets/sample/__init__.py,sha256=GL84vdZl_SjHDGVyh9Uekx2XhPYuZ0dnO3l6f6KXnHI,100
 ocf_data_sampler/torch_datasets/sample/base.py,sha256=cQ1oIyhdmlotejZK8B3Cw6MNvpdnBPD8G_o2h7Ye4Vc,2206
 ocf_data_sampler/torch_datasets/sample/site.py,sha256=40NwNTqjL1WVhPdwe02zDHHfDLG2u_bvCfRCtGAtFc0,1466
 ocf_data_sampler/torch_datasets/sample/uk_regional.py,sha256=Xx5cBYUyaM6PGUWQ76MHT9hwj6IJ7WAOxbpmYFbJGhc,10483
-ocf_data_sampler/torch_datasets/utils/__init__.py,sha256=_UHLL_yRzhLJVHi6ROSaSe8TGw80CAhU325uCZj7XkY,331
+ocf_data_sampler/torch_datasets/utils/__init__.py,sha256=TNSYuSSmFgjsvvJxtoDrH645Z64CHsNUUQ0iayTccP4,416
+ocf_data_sampler/torch_datasets/utils/add_alterate_coordinate_projections.py,sha256=w6Q4TyxNyl7PKAbhqiXvqOpnqIjwmOUcGREIvPNGYlQ,2666
 ocf_data_sampler/torch_datasets/utils/config_normalization_values_to_dicts.py,sha256=jS3DkAwOF1W3AQnvsdkBJ1C8Unm93kQbS8hgTCtFv2A,1743
 ocf_data_sampler/torch_datasets/utils/merge_and_fill_utils.py,sha256=we7BTxRH7B7jKayDT7YfNyfI3zZClz2Bk-HXKQIokgU,956
 ocf_data_sampler/torch_datasets/utils/spatial_slice_for_dataset.py,sha256=Hvz0wHSWMYYamf2oHNiGlzJcM4cAH6pL_7ZEvIBL2dE,1882
@@ -55,7 +56,7 @@ ocf_data_sampler/torch_datasets/utils/valid_time_periods.py,sha256=xcy75cVxl0Wrg
 ocf_data_sampler/torch_datasets/utils/validation_utils.py,sha256=YqmT-lExWlI8_ul3l0EP73Ik002fStr_bhsZh9mQqEU,4735
 scripts/download_gsp_location_data.py,sha256=rRDXMoqX-RYY4jPdxhdlxJGhWdl6r245F5UARgKV6P4,3121
 scripts/refactor_site.py,sha256=skzvsPP0Cn9yTKndzkilyNcGz4DZ88ctvCJ0XrBdc2A,3135
-ocf_data_sampler-0.5.9.dist-info/METADATA,sha256=LUgQmrakbDwIEfeP_3IojePDYDdvm15iUtftl5o8Rps,12816
-ocf_data_sampler-0.5.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ocf_data_sampler-0.5.9.dist-info/top_level.txt,sha256=deUxqmsONNAGZDNbsntbXH7BRA1MqWaUeAJrCo6q_xA,25
-ocf_data_sampler-0.5.9.dist-info/RECORD,,
+ocf_data_sampler-0.5.10.dist-info/METADATA,sha256=01gjKqxXj0DCTPUBsUULi_WQACkpZlS3wWM5pJ8qrmw,12817
+ocf_data_sampler-0.5.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ocf_data_sampler-0.5.10.dist-info/top_level.txt,sha256=deUxqmsONNAGZDNbsntbXH7BRA1MqWaUeAJrCo6q_xA,25
+ocf_data_sampler-0.5.10.dist-info/RECORD,,