Merge pull request #1514 from ie3-institute/sp/#1511-weather-source-timeseries

Implementing time series retrieval for `WeatherSource`

Author: staudtMarius

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Updated Authors.md file [#1503](https://github.com/ie3-institute/simona/issues/1503)
 - Quantity to squants conversion in WeatherService [#1506](https://github.com/ie3-institute/simona/issues/1506)
 - Considering primary data that start before simulation [#1034](https://github.com/ie3-institute/simona/issues/1034)
+- Implement time series retrieval for WeatherSource [#1511](https://github.com/ie3-institute/simona/issues/1511)
 
 ### Changed
 - Upgraded `scala2` to `scala3` [#53](https://github.com/ie3-institute/simona/issues/53)

src/main/scala/edu/ie3/simona/service/weather/SampleWeatherSource.scala

@@ -9,6 +9,7 @@ package edu.ie3.simona.service.weather
 import edu.ie3.datamodel.io.source.IdCoordinateSource
 import edu.ie3.datamodel.models.input.NodeInput
 import edu.ie3.simona.service.Data.SecondaryData.WeatherData
+import edu.ie3.simona.service.weather.WeatherSource.WeightedCoordinates
 import edu.ie3.simona.util.TickUtil
 import edu.ie3.simona.util.TickUtil.*
 import edu.ie3.util.geo.CoordinateDistance
@@ -26,6 +27,7 @@ import java.time.temporal.ChronoField.{HOUR_OF_DAY, MONTH_OF_YEAR, YEAR}
 import java.util
 import java.util.{Collections, Optional}
 import javax.measure.quantity.Length
+import scala.collection.SortedMap
 import scala.jdk.CollectionConverters.*
 
 final class SampleWeatherSource(
@@ -38,20 +40,17 @@ final class SampleWeatherSource(
   override val maxCoordinateDistance: ComparableQuantity[Length] =
     Quantities.getQuantity(50000d, Units.METRE)
 
-  /** Get the weather data for the given tick as a weighted average taking into
-    * account the given weighting of weather coordinates.
-    *
-    * @param tick
-    *   Simulation date in question
-    * @param weightedCoordinates
-    *   The coordinate in question
-    * @return
-    *   Matching weather data
-    */
   override def getWeather(
-      tick: Long,
-      weightedCoordinates: WeatherSource.WeightedCoordinates,
-  ): WeatherData = getWeather(tick)
+      startTick: Long,
+      endTick: Long,
+      weightedCoordinates: WeightedCoordinates,
+  ): SortedMap[ZonedDateTime, WeatherData] =
+    Range.Long
+      .inclusive(startTick, endTick, resolution)
+      .map { tick =>
+        tick.toDateTime -> getWeather(tick)
+      }
+      .to(SortedMap)
 
   /** Get the weather data for the given tick and coordinate. Here, the weather
     * data is taken repeatedly from a store The coordinate is not considered at

src/main/scala/edu/ie3/simona/service/weather/WeatherSource.scala

@@ -46,6 +46,7 @@ import tech.units.indriya.unit.Units
 import java.nio.file.Paths
 import java.time.ZonedDateTime
 import javax.measure.quantity.{Dimensionless, Length}
+import scala.collection.SortedMap
 import scala.jdk.CollectionConverters.*
 import scala.jdk.OptionConverters.RichOptional
 import scala.util.{Failure, Success, Try}
@@ -197,11 +198,29 @@ trait WeatherSource {
     }
   }
 
+  /** Get the weather data between (and including) given ticks as a weighted
+    * average taking into account the given weighting of weather coordinates.
+    *
+    * @param startTick
+    *   The first tick to retrieve weather for
+    * @param endTick
+    *   The last tick to retrieve weather for
+    * @param weightedCoordinates
+    *   The coordinate in question
+    * @return
+    *   Matching weather data
+    */
+  def getWeather(
+      startTick: Long,
+      endTick: Long,
+      weightedCoordinates: WeightedCoordinates,
+  ): SortedMap[ZonedDateTime, WeatherData]
+
   /** Get the weather data for the given tick as a weighted average taking into
     * account the given weighting of weather coordinates.
     *
     * @param tick
-    *   Simulation date in question
+    *   Simulation tick in question
     * @param weightedCoordinates
     *   The coordinate in question
     * @return
@@ -210,7 +229,13 @@ trait WeatherSource {
   def getWeather(
       tick: Long,
       weightedCoordinates: WeightedCoordinates,
-  ): WeatherData
+  ): WeatherData = {
+    getWeather(tick, tick, weightedCoordinates).values.headOption.getOrElse(
+      throw new SourceException(
+        s"No weather data received for tick $tick."
+      )
+    )
+  }
 
   /** Get the weather data for the given tick and agent coordinates having a
     * weighted average of weather values.

src/main/scala/edu/ie3/simona/service/weather/WeatherSourceWrapper.scala

@@ -44,19 +44,20 @@ import edu.ie3.simona.service.weather.WeatherSource as SimonaWeatherSource
 import edu.ie3.simona.util.TickUtil.{RichZonedDateTime, TickLong}
 import edu.ie3.util.DoubleUtils.!~=
 import edu.ie3.util.interval.ClosedInterval
+import org.locationtech.jts.geom.Point
 import squants.thermal.Kelvin
 import tech.units.indriya.ComparableQuantity
 
 import java.nio.file.Paths
 import java.time.ZonedDateTime
 import java.time.format.DateTimeFormatter
 import javax.measure.quantity.Length
+import scala.collection.SortedMap
 import scala.jdk.CollectionConverters.{
   CollectionHasAsScala,
   IterableHasAsJava,
   MapHasAsScala,
 }
-import scala.jdk.OptionConverters.RichOptional
 import scala.util.{Failure, Success, Try}
 
 /** This class provides an implementation of the SIMONA trait
@@ -83,58 +84,58 @@ private[weather] final case class WeatherSourceWrapper private (
 ) extends SimonaWeatherSource
     with LazyLogging {
 
-  /** Get the weather data for the given tick as a weighted average taking into
-    * account the given weighting of weather coordinates.
-    *
-    * @param tick
-    *   Simulation date in question
-    * @param weightedCoordinates
-    *   The coordinate in question
-    * @return
-    *   Matching weather data
-    */
   override def getWeather(
-      tick: Long,
+      startTick: Long,
+      endTick: Long,
       weightedCoordinates: WeatherSource.WeightedCoordinates,
-  ): WeatherData = {
-    val dateTime = tick.toDateTime
-    val interval = new ClosedInterval(dateTime, dateTime)
+  ): SortedMap[ZonedDateTime, WeatherData] = {
+    val interval = new ClosedInterval(startTick.toDateTime, endTick.toDateTime)
     val coordinates = weightedCoordinates.weighting.keys.toList.asJavaCollection
-    val results = source
+
+    source
       .getWeather(
         interval,
         coordinates,
       )
       .asScala
-      .toMap
-    val weatherDataMap = results.flatMap { case (point, timeSeries) =>
-      // change temperature scale for the upcoming calculations
-      timeSeries
-        .getValue(dateTime)
-        .toScala
-        .map(weatherValue => point -> toWeatherData(weatherValue))
-    }
-
-    weatherDataMap.foldLeft((EMPTY_WEATHER_DATA, WeightSum.EMPTY_WEIGHT_SUM)) {
-      case ((averagedWeather, currentWeightSum), (point, currentWeather)) =>
-        /** Calculate the contribution of a single coordinate value to the
-          * averaged weather information. If we got an empty quantity (which can
-          * be the case, as this particular value might be missing in the
-          * weather data), we do let it out and also return the "effective"
-          * weight of 0d.
-          */
-
-        /* Get pre-calculated weight for this coordinate */
+      .map { case (coordinate, timeSeries) =>
+        timeSeries.getEntries.asScala.map { weatherValue =>
+          (weatherValue.getTime, coordinate) -> weatherValue.getValue
+        }.toMap
+      }
+      .flatten
+      .groupMap { case ((time, _), _) =>
+        time
+      } { case ((_, location), weatherValue) =>
         val weight = weightedCoordinates.weighting.getOrElse(
-          point, {
-            logger.warn(s"Received an unexpected point: $point")
+          location, {
+            logger.warn(s"Received an unexpected point: $location")
             0d
           },
         )
-        /* Sum up weight and contributions */
+        val weatherData = toWeatherData(weatherValue)
+        (location, weatherData, weight)
+      }
+      .map { case (time, weather) =>
+        time -> spatialDataInterpolation(weather)
+      }
+      .to(SortedMap)
+  }
+
+  private def spatialDataInterpolation(
+      weatherData: Iterable[(Point, WeatherData, Double)]
+  ): WeatherData =
+    weatherData.foldLeft((EMPTY_WEATHER_DATA, WeightSum.EMPTY_WEIGHT_SUM)) {
+      case ((averagedWeather, weightSum), (point, weather, weight)) =>
+        /* Calculate the contribution of a single coordinate value to the
+         * averaged weather information. If we got an empty quantity (which can
+         * be the case, as this particular value might be missing in the
+         * weather data), we do let it out and also return the "effective"
+         * weight of 0d.
+         */
 
         /* Determine actual weights and contributions */
-        val (diffIrradiance, diffIrrWeight) = currentWeather.diffIrr match {
+        val (diffIrradiance, diffIrrWeight) = weather.diffIrr match {
           case EMPTY_WEATHER_DATA.diffIrr =>
             // Some data sets do not provide diffuse irradiance, so we do not
             // warn here
@@ -144,15 +145,15 @@ private[weather] final case class WeatherSourceWrapper private (
             (averagedWeather.diffIrr + nonEmptyDiffIrr * weight, weight)
         }
 
-        val (dirIrradience, dirIrrWeight) = currentWeather.dirIrr match {
+        val (dirIrradiance, dirIrrWeight) = weather.dirIrr match {
           case EMPTY_WEATHER_DATA.`dirIrr` =>
             logger.warn(s"Direct solar irradiance not available at $point.")
             (averagedWeather.dirIrr, 0d)
           case nonEmptyDirIrr =>
             (averagedWeather.dirIrr + nonEmptyDirIrr * weight, weight)
         }
 
-        val (temperature, tempWeight) = currentWeather.temp match {
+        val (temperature, tempWeight) = weather.temp match {
           case EMPTY_WEATHER_DATA.temp =>
             logger.warn(s"Temperature not available at $point.")
             (averagedWeather.temp, 0d)
@@ -162,7 +163,7 @@ private[weather] final case class WeatherSourceWrapper private (
             (averagedWeather.temp + nonEmptyTemp.in(Kelvin) * weight, weight)
         }
 
-        val (windVelocity, windVelWeight) = currentWeather.windVel match {
+        val (windVelocity, windVelWeight) = weather.windVel match {
           case EMPTY_WEATHER_DATA.windVel =>
             logger.warn(s"Wind velocity not available at $point.")
             (averagedWeather.windVel, 0d)
@@ -171,8 +172,8 @@ private[weather] final case class WeatherSourceWrapper private (
         }
 
         (
-          WeatherData(diffIrradiance, dirIrradience, temperature, windVelocity),
-          currentWeightSum.add(
+          WeatherData(diffIrradiance, dirIrradiance, temperature, windVelocity),
+          weightSum.add(
             diffIrrWeight,
             dirIrrWeight,
             tempWeight,
@@ -183,18 +184,7 @@ private[weather] final case class WeatherSourceWrapper private (
       case (weatherData: WeatherData, weightSum: WeightSum) =>
         weightSum.scale(weatherData)
     }
-  }
 
-  /** Determine an Array with all ticks between the request frame's start and
-    * end on which new data is available
-    *
-    * @param requestFrameStart
-    *   Beginning of the announced request frame
-    * @param requestFrameEnd
-    *   End of the announced request frame
-    * @return
-    *   Array with data ticks
-    */
   override def getDataTicks(
       requestFrameStart: Long,
       requestFrameEnd: Long,

src/test/scala/edu/ie3/simona/service/weather/WeatherSourceSpec.scala

@@ -22,9 +22,11 @@ import tech.units.indriya.ComparableQuantity
 import tech.units.indriya.quantity.Quantities
 import tech.units.indriya.unit.Units
 
+import java.time.ZonedDateTime
 import java.util
 import java.util.Optional
 import javax.measure.quantity.Length
+import scala.collection.SortedMap
 import scala.jdk.CollectionConverters.*
 import scala.jdk.OptionConverters.*
 import scala.util.{Failure, Success}
@@ -298,35 +300,15 @@ case object WeatherSourceSpec {
     override protected val maxCoordinateDistance: ComparableQuantity[Length] =
       Quantities.getQuantity(400000, Units.METRE)
 
-    /** Get the weather data for the given tick as a weighted average taking
-      * into account the given weighting of weather coordinates.
-      *
-      * @param tick
-      *   Simulation date in question
-      * @param weightedCoordinates
-      *   The coordinate in question
-      * @return
-      *   Matching weather data
-      */
     override def getWeather(
-        tick: Long,
+        startTick: Long,
+        endTick: Long,
         weightedCoordinates: WeightedCoordinates,
-    ): WeatherData =
+    ): SortedMap[ZonedDateTime, WeatherData] =
       throw new UnsupportedOperationException(
         "This is not supported by the dummy source."
       )
 
-    /** Determine an Array with all ticks between the request frame's start and
-      * end on which new data is available. Bot the request frame's start and
-      * end are INCLUDED.
-      *
-      * @param requestFrameStart
-      *   Beginning of the announced request frame
-      * @param requestFrameEnd
-      *   End of the announced request frame
-      * @return
-      *   Array with data ticks
-      */
     override def getDataTicks(
         requestFrameStart: Long,
         requestFrameEnd: Long,