Handling no received data from WeatherSource

AUTHORS

@@ -28,4 +28,5 @@ Main Contributers:
     - Johannes Bao - https://github.com/jo-bao
     - Julian Hohmann - https://github.com/julianhohmann
     - Simon Huette - https://github.com/SimonHuette
-    - Pierre Petersmeier - http://github.com/pierrepetersmeier
+    - Pierre Petersmeier - https://github.com/pierrepetersmeier
+    - Philipp Schmelter - https://github.com/PhilippSchmelter

CHANGELOG.md

@@ -78,6 +78,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Enhance `TimeSeriesSource` with method to retrieve all time keys after a given key [#543](https://github.com/ie3-institute/PowerSystemDataModel/issues/543)
 - Enhance `WeatherSource` with method to retrieve all time keys after a given key [#572](https://github.com/ie3-institute/PowerSystemDataModel/issues/572)
+- Added explicit handling for cases where no weather data is received from any source [#554](https://github.com/ie3-institute/PowerSystemDataModel/issues/554)
 - Adding timeseries for voltage values [#1128](https://github.com/ie3-institute/PowerSystemDataModel/issues/1128)
 - Added Staudt to list of reviewers [#1190](https://github.com/ie3-institute/PowerSystemDataModel/issues/1190)
 - Extend ValidationUtils for validating ThermalGrids [#1216](https://github.com/ie3-institute/PowerSystemDataModel/issues/1216) 

src/main/java/edu/ie3/datamodel/exceptions/NoDataException.java

@@ -0,0 +1,21 @@
+/*
+ * © 2024. TU Dortmund University,
+ * Institute of Energy Systems, Energy Efficiency and Energy Economics,
+ * Research group Distribution grid planning and operation
+*/
+package edu.ie3.datamodel.exceptions;
+
+/**
+ * Exception that should be used whenever no data is received{@link
+ * edu.ie3.datamodel.io.source.DataSource}
+ */
+public class NoDataException extends Exception {
+
+  public NoDataException(final String message) {
+    super(message);
+  }
+
+  public NoDataException(final String message, final Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/edu/ie3/datamodel/io/source/WeatherSource.java

@@ -5,6 +5,7 @@
 */
 package edu.ie3.datamodel.io.source;
 
+import edu.ie3.datamodel.exceptions.NoDataException;
 import edu.ie3.datamodel.exceptions.SourceException;
 import edu.ie3.datamodel.exceptions.ValidationException;
 import edu.ie3.datamodel.io.factory.timeseries.TimeBasedWeatherValueData;
@@ -55,14 +56,14 @@ public void validate() throws ValidationException {
   // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
   public abstract Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval) throws SourceException;
+      ClosedInterval<ZonedDateTime> timeInterval) throws SourceException, NoDataException;
 
   public abstract Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
       ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates)
-      throws SourceException;
+      throws SourceException, NoDataException;
 
-  public abstract Optional<TimeBasedValue<WeatherValue>> getWeather(
-      ZonedDateTime date, Point coordinate) throws SourceException;
+  public abstract TimeBasedValue<WeatherValue> getWeather(ZonedDateTime date, Point coordinate)
+      throws SourceException, NoDataException;
 
   public abstract Map<Point, List<ZonedDateTime>> getTimeKeysAfter(ZonedDateTime time)
       throws SourceException;

src/main/java/edu/ie3/datamodel/io/source/couchbase/CouchbaseWeatherSource.java

@@ -10,6 +10,7 @@
 import com.couchbase.client.java.json.JsonObject;
 import com.couchbase.client.java.kv.GetResult;
 import com.couchbase.client.java.query.QueryResult;
+import edu.ie3.datamodel.exceptions.NoDataException;
 import edu.ie3.datamodel.io.connectors.CouchbaseConnector;
 import edu.ie3.datamodel.io.factory.timeseries.TimeBasedWeatherValueData;
 import edu.ie3.datamodel.io.factory.timeseries.TimeBasedWeatherValueFactory;
@@ -105,7 +106,7 @@ public Optional<Set<String>> getSourceFields() {
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval) {
+      ClosedInterval<ZonedDateTime> timeInterval) throws NoDataException {
     logger.warn(
         "By not providing coordinates you are forcing couchbase to check all possible coordinates one by one."
             + " This is not very performant. Please consider providing specific coordinates instead.");
@@ -114,7 +115,18 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates) {
+      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates)
+      throws NoDataException {
+
+    List<Point> invalidCoordinates =
+        coordinates.stream()
+            .filter(coordinate -> idCoordinateSource.getId(coordinate).isEmpty())
+            .toList();
+
+    if (!invalidCoordinates.isEmpty()) {
+      throw new NoDataException("No data for given coordinates: " + invalidCoordinates);
+    }
+
     HashMap<Point, IndividualTimeSeries<WeatherValue>> coordinateToTimeSeries = new HashMap<>();
     for (Point coordinate : coordinates) {
       Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
@@ -126,7 +138,8 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
         try {
           jsonWeatherInputs = queryResult.rowsAsObject();
         } catch (DecodingFailureException ex) {
-          logger.error("Querying weather inputs failed!", ex);
+          throw new NoDataException(
+              "Failed to decode weather data for coordinate " + coordinate, ex);
         }
         if (jsonWeatherInputs != null && !jsonWeatherInputs.isEmpty()) {
           Set<TimeBasedValue<WeatherValue>> weatherInputs =
@@ -138,32 +151,52 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
               new IndividualTimeSeries<>(weatherInputs);
           coordinateToTimeSeries.put(coordinate, weatherTimeSeries);
         }
-      } else logger.warn("Unable to match coordinate {} to a coordinate ID", coordinate);
+      }
     }
     return coordinateToTimeSeries;
   }
 
   @Override
-  public Optional<TimeBasedValue<WeatherValue>> getWeather(ZonedDateTime date, Point coordinate) {
+  public TimeBasedValue<WeatherValue> getWeather(ZonedDateTime date, Point coordinate)
+      throws NoDataException {
     Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
     if (coordinateId.isEmpty()) {
-      logger.warn("Unable to match coordinate {} to a coordinate ID", coordinate);
-      return Optional.empty();
+      logger.error("Unable to match coordinate {} to a coordinate ID", coordinate);
+      throw new NoDataException("No coordinate ID found for the given point: " + coordinate);
     }
     try {
       CompletableFuture<GetResult> futureResult =
           connector.get(generateWeatherKey(date, coordinateId.get()));
       GetResult getResult = futureResult.join();
       JsonObject jsonWeatherInput = getResult.contentAsObject();
-      return toTimeBasedWeatherValue(jsonWeatherInput);
+      return toTimeBasedWeatherValue(jsonWeatherInput)
+          .orElseThrow(
+              () ->
+                  new NoDataException(
+                      "No valid weather data found for the given date and coordinate."));
     } catch (DecodingFailureException ex) {
-      logger.error("Decoding to TimeBasedWeatherValue failed!", ex);
-      return Optional.empty();
+      throw new NoDataException(
+          "Failed to decode weather data for coordinate " + coordinate + " and date " + date, ex);
     } catch (DocumentNotFoundException ex) {
-      return Optional.empty();
+      throw new NoDataException(
+          "Weather document not found for coordinate " + coordinate + " and date " + date, ex);
     } catch (CompletionException ex) {
-      if (ex.getCause() instanceof DocumentNotFoundException) return Optional.empty();
-      else throw ex;
+      Throwable cause = ex.getCause();
+      if (cause instanceof DocumentNotFoundException) {
+        throw new NoDataException(
+            "Weather document not found in completion stage for coordinate "
+                + coordinate
+                + " and date "
+                + date,
+            cause);
+      } else {
+        throw new NoDataException(
+            "Unexpected completion exception while retrieving weather data for coordinate "
+                + coordinate
+                + " and date "
+                + date,
+            ex);
+      }
     }
   }
 

src/main/java/edu/ie3/datamodel/io/source/csv/CsvWeatherSource.java

@@ -8,6 +8,7 @@
 import static edu.ie3.datamodel.utils.validation.UniquenessValidationUtils.checkWeatherUniqueness;
 
 import edu.ie3.datamodel.exceptions.DuplicateEntitiesException;
+import edu.ie3.datamodel.exceptions.NoDataException;
 import edu.ie3.datamodel.exceptions.SourceException;
 import edu.ie3.datamodel.exceptions.ValidationException;
 import edu.ie3.datamodel.io.connectors.CsvFileConnector;
@@ -90,25 +91,63 @@ public Optional<Set<String>> getSourceFields() {
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval) {
-    return trimMapToInterval(coordinateToTimeSeries, timeInterval);
+      ClosedInterval<ZonedDateTime> timeInterval) throws NoDataException {
+
+    Map<Point, IndividualTimeSeries<WeatherValue>> result =
+        trimMapToInterval(coordinateToTimeSeries, timeInterval);
+
+    if (result == null || result.isEmpty()) {
+      throw new NoDataException(
+          "No weather data found for the given time interval: " + timeInterval);
+    }
+
+    return result;
   }
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates) {
+      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates)
+      throws NoDataException {
+
+    List<Point> invalidCoordinates =
+        coordinates.stream()
+            .filter(coordinate -> !coordinateToTimeSeries.containsKey(coordinate))
+            .toList();
+
+    if (!invalidCoordinates.isEmpty()) {
+      throw new NoDataException("No data for given coordinates: " + invalidCoordinates);
+    }
+
     Map<Point, IndividualTimeSeries<WeatherValue>> filteredMap =
         coordinateToTimeSeries.entrySet().stream()
             .filter(entry -> coordinates.contains(entry.getKey()))
             .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-    return trimMapToInterval(filteredMap, timeInterval);
+
+    Map<Point, IndividualTimeSeries<WeatherValue>> result =
+        trimMapToInterval(filteredMap, timeInterval);
+
+    if (result == null || result.isEmpty()) {
+      throw new NoDataException(
+          "No weather data found for the given time interval: " + timeInterval);
+    }
+    return result;
   }
 
   @Override
-  public Optional<TimeBasedValue<WeatherValue>> getWeather(ZonedDateTime date, Point coordinate) {
+  public TimeBasedValue<WeatherValue> getWeather(ZonedDateTime date, Point coordinate)
+      throws NoDataException {
     IndividualTimeSeries<WeatherValue> timeSeries = coordinateToTimeSeries.get(coordinate);
-    if (timeSeries == null) return Optional.empty();
-    return timeSeries.getTimeBasedValue(date);
+
+    if (timeSeries == null) {
+      throw new NoDataException("No weather data found for the given coordinate: " + coordinate);
+    }
+
+    return timeSeries
+        .getTimeBasedValue(date)
+        .orElseThrow(
+            () ->
+                new NoDataException(
+                    "No weather data found for the given coordinate: " + coordinate));
   }
 
   @Override

src/main/java/edu/ie3/datamodel/io/source/influxdb/InfluxDbWeatherSource.java

@@ -5,6 +5,7 @@
 */
 package edu.ie3.datamodel.io.source.influxdb;
 
+import edu.ie3.datamodel.exceptions.NoDataException;
 import edu.ie3.datamodel.io.connectors.InfluxDbConnector;
 import edu.ie3.datamodel.io.factory.timeseries.TimeBasedWeatherValueData;
 import edu.ie3.datamodel.io.factory.timeseries.TimeBasedWeatherValueFactory;
@@ -59,14 +60,18 @@ public Optional<Set<String>> getSourceFields() {
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval) {
+      ClosedInterval<ZonedDateTime> timeInterval) throws NoDataException {
     try (InfluxDB session = connector.getSession()) {
       String query = createQueryStringForTimeInterval(timeInterval);
       QueryResult queryResult = session.query(new Query(query));
       Stream<Optional<TimeBasedValue<WeatherValue>>> optValues =
           optTimeBasedValueStream(queryResult);
       Set<TimeBasedValue<WeatherValue>> timeBasedValues =
           filterEmptyOptionals(optValues).collect(Collectors.toSet());
+      if (timeBasedValues.isEmpty()) {
+        throw new NoDataException(
+            "No weather data found for the given time interval: " + timeInterval);
+      }
       Map<Point, Set<TimeBasedValue<WeatherValue>>> coordinateToValues =
           timeBasedValues.stream()
               .collect(
@@ -81,10 +86,22 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates) {
+      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates)
+      throws NoDataException {
     if (coordinates == null) return getWeather(timeInterval);
     Map<Point, Optional<Integer>> coordinatesToId =
         coordinates.stream().collect(Collectors.toMap(point -> point, idCoordinateSource::getId));
+
+    List<Point> invalidCoordinates =
+        coordinatesToId.entrySet().stream()
+            .filter(entry -> entry.getValue().isEmpty())
+            .map(Map.Entry::getKey)
+            .toList();
+
+    if (!invalidCoordinates.isEmpty()) {
+      throw new NoDataException("No data for given coordinates: " + invalidCoordinates);
+    }
+
     HashMap<Point, IndividualTimeSeries<WeatherValue>> coordinateToTimeSeries = new HashMap<>();
     try (InfluxDB session = connector.getSession()) {
       for (Map.Entry<Point, Optional<Integer>> entry : coordinatesToId.entrySet()) {
@@ -97,25 +114,37 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
               optTimeBasedValueStream(queryResult);
           Set<TimeBasedValue<WeatherValue>> timeBasedValues =
               filterEmptyOptionals(optValues).collect(Collectors.toSet());
-          IndividualTimeSeries<WeatherValue> timeSeries =
-              new IndividualTimeSeries<>(timeBasedValues);
-          coordinateToTimeSeries.put(entry.getKey(), timeSeries);
+          if (!timeBasedValues.isEmpty()) {
+            IndividualTimeSeries<WeatherValue> timeSeries =
+                new IndividualTimeSeries<>(timeBasedValues);
+            coordinateToTimeSeries.put(entry.getKey(), timeSeries);
+          }
         }
       }
     }
     return coordinateToTimeSeries;
   }
 
   @Override
-  public Optional<TimeBasedValue<WeatherValue>> getWeather(ZonedDateTime date, Point coordinate) {
+  public TimeBasedValue<WeatherValue> getWeather(ZonedDateTime date, Point coordinate)
+      throws NoDataException {
     Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
     if (coordinateId.isEmpty()) {
-      return Optional.empty();
+      throw new NoDataException("No coordinate ID found for the given point: " + coordinate);
     }
+
     try (InfluxDB session = connector.getSession()) {
       String query = createQueryStringForCoordinateAndTime(date, coordinateId.get());
       QueryResult queryResult = session.query(new Query(query));
-      return filterEmptyOptionals(optTimeBasedValueStream(queryResult)).findFirst();
+      return filterEmptyOptionals(optTimeBasedValueStream(queryResult))
+          .findFirst()
+          .orElseThrow(
+              () ->
+                  new NoDataException(
+                      "No weather data available for the given date "
+                          + date
+                          + " and coordinate "
+                          + coordinate));
     }
   }
 
@@ -167,10 +196,10 @@ public List<ZonedDateTime> getTimeKeysAfter(ZonedDateTime time, Point coordinate
    * @return weather data for the specified time and coordinate
    */
   public IndividualTimeSeries<WeatherValue> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval, Point coordinate) {
+      ClosedInterval<ZonedDateTime> timeInterval, Point coordinate) throws NoDataException {
     Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
     if (coordinateId.isEmpty()) {
-      return new IndividualTimeSeries<>(UUID.randomUUID(), Collections.emptySet());
+      throw new NoDataException("No data for given coordinates: " + coordinate);
     }
     try (InfluxDB session = connector.getSession()) {
       String query =