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

@@ -11,6 +11,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) 
@@ -23,6 +24,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Validation for BDEW load profile values [#1243](https://github.com/ie3-institute/PowerSystemDataModel/issues/1243)
 - Added load profiles sources [#1106](https://github.com/ie3-institute/PowerSystemDataModel/issues/1106)
 
+
 ### Fixed
 - Removing opened `SwitchInput` during connectivity check [#1221](https://github.com/ie3-institute/PowerSystemDataModel/issues/1221)
 - Fixed example in ReadTheDocs [#1244](https://github.com/ie3-institute/PowerSystemDataModel/issues/1244)

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

@@ -0,0 +1,20 @@
+/*
+ * © 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}
+ *
+ * @version 0.1
+ * @since 04.09.24
+ */
+public class NoDataException extends Exception {
+
+  public NoDataException(final String message) {
+    super(message);
+  }
+}

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;
@@ -104,7 +105,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.");
@@ -113,7 +114,8 @@ 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 {
     HashMap<Point, IndividualTimeSeries<WeatherValue>> coordinateToTimeSeries = new HashMap<>();
     for (Point coordinate : coordinates) {
       Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
@@ -137,32 +139,41 @@ 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);
+      } else {
+        logger.error("Unable to match coordinate {} to a coordinate ID", coordinate);
+        throw new NoDataException("No data found");
+      }
     }
     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.");
     }
     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.");
     } catch (DocumentNotFoundException ex) {
-      return Optional.empty();
+      throw new NoDataException("Weather document not found.");
     } catch (CompletionException ex) {
-      if (ex.getCause() instanceof DocumentNotFoundException) return Optional.empty();
-      else throw ex;
+      if (ex.getCause() instanceof DocumentNotFoundException) {
+        throw new NoDataException("Weather document not found in the completion stage.");
+      } else throw 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,48 @@ 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.");
+    }
+
+    return result;
   }
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates) {
+      ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates)
+      throws NoDataException {
     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.");
+    }
+    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");
+    }
+
+    return timeSeries
+        .getTimeBasedValue(date)
+        .orElseThrow(() -> new NoDataException("No weather data found for the given 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;
@@ -67,6 +68,9 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
           optTimeBasedValueStream(queryResult);
       Set<TimeBasedValue<WeatherValue>> timeBasedValues =
           filterEmptyOptionals(optValues).collect(Collectors.toSet());
+      if (timeBasedValues.isEmpty()) {
+        throw new NoDataException("No weather data found");
+      }
       Map<Point, Set<TimeBasedValue<WeatherValue>>> coordinateToValues =
           timeBasedValues.stream()
               .collect(
@@ -76,6 +80,9 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
       return coordinateToValues.entrySet().stream()
           .collect(
               Collectors.toMap(Map.Entry::getKey, e -> new IndividualTimeSeries<>(e.getValue())));
+    } catch (NoDataException e) {
+      log.error("No data available for coordinate", e);
+      return Collections.emptyMap();
     }
   }
 
@@ -97,25 +104,43 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
               optTimeBasedValueStream(queryResult);
           Set<TimeBasedValue<WeatherValue>> timeBasedValues =
               filterEmptyOptionals(optValues).collect(Collectors.toSet());
+          if (timeBasedValues.isEmpty()) {
+            throw new NoDataException("No weather data found");
+          }
           IndividualTimeSeries<WeatherValue> timeSeries =
               new IndividualTimeSeries<>(timeBasedValues);
           coordinateToTimeSeries.put(entry.getKey(), timeSeries);
         }
       }
+    } catch (NoDataException e) {
+      return Collections.emptyMap();
     }
     return coordinateToTimeSeries;
   }
 
   @Override
-  public Optional<TimeBasedValue<WeatherValue>> getWeather(ZonedDateTime date, Point coordinate) {
-    Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
-    if (coordinateId.isEmpty()) {
-      return Optional.empty();
+  public TimeBasedValue<WeatherValue> getWeather(ZonedDateTime date, Point coordinate)
+      throws NoDataException {
+    Optional<Integer> coordinateId;
+    try {
+      coordinateId = idCoordinateSource.getId(coordinate);
+      if (coordinateId.isEmpty()) {
+        throw new NoDataException("No coordinate ID found for the given point.");
+      }
+    } catch (NoDataException e) {
+      log.error("No data available for coordinate {} and date {}", coordinate, date, e);
+      return null;
     }
+
     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 and coordinate."));
     }
   }
 
@@ -167,9 +192,14 @@ 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) {
-    Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
-    if (coordinateId.isEmpty()) {
+      ClosedInterval<ZonedDateTime> timeInterval, Point coordinate) throws NoDataException {
+    Optional<Integer> coordinateId;
+    try {
+      coordinateId = idCoordinateSource.getId(coordinate);
+      if (coordinateId.isEmpty()) {
+        throw new NoDataException("No data for given coordinates");
+      }
+    } catch (NoDataException e) {
       return new IndividualTimeSeries<>(UUID.randomUUID(), Collections.emptySet());
     }
     try (InfluxDB session = connector.getSession()) {

src/main/java/edu/ie3/datamodel/io/source/sql/SqlWeatherSource.java

@@ -7,6 +7,7 @@
 
 import static edu.ie3.datamodel.io.source.sql.SqlDataSource.createBaseQueryString;
 
+import edu.ie3.datamodel.exceptions.NoDataException;
 import edu.ie3.datamodel.exceptions.SourceException;
 import edu.ie3.datamodel.io.connectors.SqlConnector;
 import edu.ie3.datamodel.io.factory.timeseries.TimeBasedWeatherValueFactory;
@@ -92,7 +93,7 @@ public Optional<Set<String>> getSourceFields() {
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
-      ClosedInterval<ZonedDateTime> timeInterval) throws SourceException {
+      ClosedInterval<ZonedDateTime> timeInterval) throws NoDataException, SourceException {
     List<TimeBasedValue<WeatherValue>> timeBasedValues =
         buildTimeBasedValues(
             weatherFactory,
@@ -102,20 +103,28 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
                   ps.setTimestamp(1, Timestamp.from(timeInterval.getLower().toInstant()));
                   ps.setTimestamp(2, Timestamp.from(timeInterval.getUpper().toInstant()));
                 }));
+    if (timeBasedValues.isEmpty()) {
+      throw new NoDataException("No weather data found");
+    }
     return mapWeatherValuesToPoints(timeBasedValues);
   }
 
   @Override
   public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
       ClosedInterval<ZonedDateTime> timeInterval, Collection<Point> coordinates)
-      throws SourceException {
-    Set<Integer> coordinateIds =
-        coordinates.stream()
-            .map(idCoordinateSource::getId)
-            .flatMap(Optional::stream)
-            .collect(Collectors.toSet());
-    if (coordinateIds.isEmpty()) {
-      log.warn("Unable to match coordinates to coordinate ID");
+      throws SourceException, NoDataException {
+    Set<Integer> coordinateIds;
+    try {
+      coordinateIds =
+          coordinates.stream()
+              .map(idCoordinateSource::getId)
+              .flatMap(Optional::stream)
+              .collect(Collectors.toSet());
+      if (coordinateIds.isEmpty()) {
+        log.warn("Unable to match coordinates to coordinate ID");
+        throw new NoDataException("No coordinates found");
+      }
+    } catch (NoDataException e) {
       return Collections.emptyMap();
     }
 
@@ -136,12 +145,18 @@ public Map<Point, IndividualTimeSeries<WeatherValue>> getWeather(
   }
 
   @Override
-  public Optional<TimeBasedValue<WeatherValue>> getWeather(ZonedDateTime date, Point coordinate)
-      throws SourceException {
-    Optional<Integer> coordinateId = idCoordinateSource.getId(coordinate);
-    if (coordinateId.isEmpty()) {
-      log.warn("Unable to match coordinate {} to a coordinate ID", coordinate);
-      return Optional.empty();
+  public TimeBasedValue<WeatherValue> getWeather(ZonedDateTime date, Point coordinate)
+      throws SourceException, NoDataException {
+    Optional<Integer> coordinateId;
+    try {
+      coordinateId = idCoordinateSource.getId(coordinate);
+      if (coordinateId.isEmpty()) {
+        log.warn("Unable to match coordinate {} to a coordinate ID", coordinate);
+        throw new NoDataException("No coordinate ID found for the given point.");
+      }
+    } catch (NoDataException e) {
+      log.error("No data available for coordinate {} and date {}", coordinate, date, e);
+      return null;
     }
 
     List<TimeBasedValue<WeatherValue>> timeBasedValues =
@@ -154,10 +169,10 @@ public Optional<TimeBasedValue<WeatherValue>> getWeather(ZonedDateTime date, Poi
                   ps.setTimestamp(2, Timestamp.from(date.toInstant()));
                 }));
 
-    if (timeBasedValues.isEmpty()) return Optional.empty();
+    if (timeBasedValues.isEmpty()) throw new NoDataException("No weather data found");
     if (timeBasedValues.size() > 1)
       log.warn("Retrieved more than one result value, using the first");
-    return Optional.of(timeBasedValues.get(0));
+    return timeBasedValues.get(0);
   }
 
   @Override