Transferring aggregation tests

Signed-off-by: Sebastian Peter <[email protected]>

Author: sebastian-peter

src/test/scala/edu/ie3/simona/model/participant2/load/LoadModelTestHelper.scala

@@ -0,0 +1,74 @@
+/*
+ * © 2024. TU Dortmund University,
+ * Institute of Energy Systems, Energy Efficiency and Energy Economics,
+ * Research group Distribution grid planning and operation
+ */
+
+package edu.ie3.simona.model.participant2.load
+
+import edu.ie3.simona.model.participant2.ParticipantModel.{
+  ActivePowerOperatingPoint,
+  DateTimeData,
+  FixedState,
+}
+import squants.{Dimensionless, Each, Energy, Power, Quantity}
+import squants.energy.KilowattHours
+import squants.time.Minutes
+
+import java.time.ZonedDateTime
+import java.time.temporal.ChronoUnit
+
+trait LoadModelTestHelper {
+
+  protected def calculateEnergyDiffForYear(
+      model: LoadModel[DateTimeData],
+      simulationStartDate: ZonedDateTime,
+      expectedEnergy: Energy,
+  ): Dimensionless = {
+    val duration = Minutes(15d)
+
+    val avgEnergy = calculatePowerForYear(
+      model,
+      simulationStartDate,
+    ).foldLeft(KilowattHours(0)) { case (energySum, power) =>
+      energySum + (power * duration)
+    }
+
+    getRelativeDifference(
+      avgEnergy,
+      expectedEnergy,
+    )
+  }
+
+  protected def calculatePowerForYear(
+      model: LoadModel[DateTimeData],
+      simulationStartDate: ZonedDateTime,
+  ): Iterable[Power] = {
+    val quarterHoursInYear = 365L * 96L
+
+    (0L until quarterHoursInYear)
+      .map { quarterHour =>
+        val tick = quarterHour * 15 * 60
+        val relevantData = DateTimeData(
+          tick,
+          simulationStartDate.plus(quarterHour * 15, ChronoUnit.MINUTES),
+        )
+
+        model
+          .determineOperatingPoint(
+            FixedState(tick),
+            relevantData,
+          ) match {
+          case (ActivePowerOperatingPoint(p), _) =>
+            p
+        }
+      }
+  }
+
+  protected def getRelativeDifference[Q <: Quantity[Q]](
+      actualResult: Q,
+      expectedResult: Q,
+  ): Dimensionless =
+    Each((expectedResult - actualResult).abs / expectedResult)
+
+}

src/test/scala/edu/ie3/simona/model/participant2/load/ProfileLoadModelSpec.scala

@@ -15,17 +15,30 @@ import edu.ie3.datamodel.models.voltagelevels.GermanVoltageLevelUtils
 import edu.ie3.simona.config.SimonaConfig.LoadRuntimeConfig
 import edu.ie3.simona.test.common.UnitSpec
 import edu.ie3.simona.test.matchers.DoubleMatchers
+import edu.ie3.util.TimeUtil
 import edu.ie3.util.quantities.PowerSystemUnits
-import edu.ie3.util.scala.quantities.{ApparentPower, Voltamperes}
+import edu.ie3.util.scala.quantities.{
+  ApparentPower,
+  Kilovoltamperes,
+  Voltamperes,
+}
+import squants.Percent
+import squants.energy.{KilowattHours, Power, Watts}
 import tech.units.indriya.quantity.Quantities
 
 import java.util.UUID
 
-class ProfileLoadModelSpec extends UnitSpec with DoubleMatchers {
+class ProfileLoadModelSpec
+    extends UnitSpec
+    with DoubleMatchers
+    with LoadModelTestHelper {
 
   private implicit val powerTolerance: ApparentPower = Voltamperes(1e-2)
   private implicit val doubleTolerance: Double = 1e-6
 
+  private val simulationStartDate =
+    TimeUtil.withDefaults.toZonedDateTime("2022-01-01T00:00:00Z")
+
   "A profile load model" should {
 
     val loadInput = new LoadInput(
@@ -126,5 +139,79 @@ class ProfileLoadModelSpec extends UnitSpec with DoubleMatchers {
 
     }
 
+    "reach the targeted annual energy consumption" in {
+      forAll(
+        Table("profile", H0, L0, G0)
+      ) { profile =>
+        val input = loadInput.copy().loadprofile(profile).build()
+
+        val config = LoadRuntimeConfig(
+          calculateMissingReactivePowerWithModel = false,
+          scaling = 1.0,
+          uuids = List.empty,
+          modelBehaviour = "profile",
+          reference = "energy",
+        )
+
+        val targetEnergyConsumption = KilowattHours(
+          loadInput
+            .geteConsAnnual()
+            .to(PowerSystemUnits.KILOWATTHOUR)
+            .getValue
+            .doubleValue
+        )
+
+        val model = ProfileLoadModel(input, config)
+
+        /* Test against a permissible deviation of 2 %. As per official documentation of the bdew load profiles
+         * [https://www.bdew.de/media/documents/2000131_Anwendung-repraesentativen_Lastprofile-Step-by-step.pdf], 1.5 %
+         * are officially permissible. But, as we currently do not take (bank) holidays into account, we cannot reach
+         * this accuracy. */
+
+        calculateEnergyDiffForYear(
+          model,
+          simulationStartDate,
+          targetEnergyConsumption,
+        ) should be < Percent(2)
+      }
+    }
+
+    "approximately reach the maximum power in a simulated year" in {
+      forAll(
+        Table("profile", H0, L0, G0)
+      ) { profile =>
+        val input = loadInput.copy().loadprofile(profile).build()
+
+        val config = LoadRuntimeConfig(
+          calculateMissingReactivePowerWithModel = false,
+          scaling = 1.0,
+          uuids = List.empty,
+          modelBehaviour = "profile",
+          reference = "power",
+        )
+
+        val model = ProfileLoadModel(input, config)
+
+        val targetMaximumPower = Kilovoltamperes(
+          input
+            .getsRated()
+            .to(PowerSystemUnits.KILOVOLTAMPERE)
+            .getValue
+            .doubleValue
+        ).toActivePower(input.getCosPhiRated)
+
+        val maximumPower = calculatePowerForYear(
+          model,
+          simulationStartDate,
+        ).maxOption.value
+
+        // the maximum value depends on the year of the simulation,
+        // since the maximum value for h0 will be reached on Saturdays in the winter
+        // and since the dynamization function reaches its maximum on day 366 (leap year)
+        implicit val tolerance: Power = Watts(1)
+        maximumPower should approximate(targetMaximumPower)
+      }
+    }
+
   }
 }