Merge pull request #1130 from ie3-institute/ms/#1128-adding-voltage-timeseries

Adding a timeseries for voltage values.

Author: sebastian-peter

CHANGELOG.md

@@ -9,6 +9,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)
+- Adding timeseries for voltage values [#1128](https://github.com/ie3-institute/PowerSystemDataModel/issues/1128)
 
 ### Fixed
 

docs/readthedocs/io/csvfiles.md

@@ -122,30 +122,34 @@ This is the UUID from the example above `2fcb3e53-b94a-4b96-bea4-c469e499f1a1`.
 The following keys are supported until now:
 ```{list-table}
    :widths: auto
+   :class: wrapping
    :header-rows: 1
 
    * - Key
-     - Information and supported head line
+     - Information and supported head line.
    * - c
      - An energy price (e.g. in €/MWh; c stands for charge).
        Permissible head line: ``time,price``
    * - p
-     - Active power
+     - Active power.
        Permissible head line: ``time,p``
    * - pq
-     - Active and reactive power
+     - Active and reactive power.
        Permissible head line: ``time,p,q``
    * - h
-     - Heat power demand
+     - Heat power demand.
        Permissible head line: ``time,h``
    * - ph
-     - Active and heat power
+     - Active and heat power.
        Permissible head line: ``time,p,h``
    * - pqh
-     - Active, reactive and heat power
+     - Active, reactive and heat power.
        Permissible head line: ``time,p,q,h``
+   * - v
+     - Voltage mangnitude in pu and angle in °.
+       Permissible head line: ``time,vMag,vAng``
    * - weather
-     - Weather information
+     - Weather information.
        Permissible head line: ``time,coordinate,direct_irradiation,diffuse_irradiation,temperature,wind_velocity,wind_direction``
 
 ```

docs/readthedocs/models/input/additionaldata/timeseries.md

@@ -48,7 +48,10 @@ The following different values are available:
      
    * - `WindValue`
      - Combination of wind direction and wind velocity
-        
+   
+   * - `VoltageValue`
+     - Combination of voltage magnitude in p.u. and angle in °
+   
    * - `WeatherValue`
      - Combination of irradiance, temperature and wind information
            

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

@@ -6,7 +6,7 @@
 package edu.ie3.datamodel.exceptions;
 
 /**
- * Is thrown, when an something went wrong during entity field mapping creation in a {@link
+ * Is thrown, when something went wrong during entity field mapping creation in a {@link
  * edu.ie3.datamodel.io.processor.EntityProcessor}
  */
 public class EntityProcessorException extends Exception {

src/main/java/edu/ie3/datamodel/io/factory/FactoryData.java

@@ -78,6 +78,22 @@ public <Q extends Quantity<Q>> ComparableQuantity<Q> getQuantity(String field, U
     return Quantities.getQuantity(getDouble(field), unit);
   }
 
+  /**
+   * Returns field value for given field name, or empty Optional if field does not exist.
+   *
+   * @param field field name
+   * @param unit unit of Quantity
+   * @param <Q> unit type parameter
+   * @return field value
+   */
+  public <Q extends Quantity<Q>> Optional<ComparableQuantity<Q>> getQuantityOptional(
+      String field, Unit<Q> unit) {
+    return Optional.ofNullable(fieldsToAttributes.get(field))
+        .filter(str -> !str.isEmpty())
+        .map(Double::parseDouble)
+        .map(value -> Quantities.getQuantity(value, unit));
+  }
+
   /**
    * Returns int value for given field name. Throws {@link FactoryException} if field does not exist
    * or parsing fails.

src/main/java/edu/ie3/datamodel/io/factory/timeseries/TimeBasedSimpleValueFactory.java

@@ -25,6 +25,10 @@ public class TimeBasedSimpleValueFactory<V extends Value>
   private static final String REACTIVE_POWER = "q";
   private static final String HEAT_DEMAND = "heatDemand";
 
+  /* voltage */
+  private static final String VMAG = "vMag";
+  private static final String VANG = "VAng";
+
   public TimeBasedSimpleValueFactory(Class<? extends V> valueClasses) {
     super(valueClasses);
   }
@@ -35,6 +39,7 @@ public TimeBasedSimpleValueFactory(
   }
 
   @Override
+  @SuppressWarnings("unchecked")
   protected TimeBasedValue<V> buildModel(SimpleTimeBasedValueData<V> data) {
     ZonedDateTime time = timeUtil.toZonedDateTime(data.getField(TIME));
     V value;
@@ -64,6 +69,12 @@ protected TimeBasedValue<V> buildModel(SimpleTimeBasedValueData<V> data) {
                   data.getQuantity(REACTIVE_POWER, REACTIVE_POWER_IN));
     } else if (PValue.class.isAssignableFrom(data.getTargetClass())) {
       value = (V) new PValue(data.getQuantity(ACTIVE_POWER, ACTIVE_POWER_IN));
+    } else if (VoltageValue.class.isAssignableFrom(data.getTargetClass())) {
+      value =
+          (V)
+              new VoltageValue(
+                  data.getQuantity(VMAG, VOLTAGE_MAGNITUDE),
+                  data.getQuantityOptional(VANG, VOLTAGE_ANGLE));
     } else {
       throw new FactoryException(
           "The given factory cannot handle target class '" + data.getTargetClass() + "'.");
@@ -88,6 +99,8 @@ protected List<Set<String>> getFields(Class<?> entityClass) {
       minConstructorParams.addAll(Arrays.asList(ACTIVE_POWER, REACTIVE_POWER));
     } else if (PValue.class.isAssignableFrom(entityClass)) {
       minConstructorParams.add(ACTIVE_POWER);
+    } else if (VoltageValue.class.isAssignableFrom(entityClass)) {
+      minConstructorParams.addAll(List.of(VMAG, VANG));
     } else {
       throw new FactoryException(
           "The given factory cannot handle target class '" + entityClass + "'.");

src/main/java/edu/ie3/datamodel/io/naming/timeseries/ColumnScheme.java

@@ -19,7 +19,8 @@ public enum ColumnScheme {
   HEAT_DEMAND("h", HeatDemandValue.class),
   ACTIVE_POWER_AND_HEAT_DEMAND("ph", HeatAndPValue.class),
   APPARENT_POWER_AND_HEAT_DEMAND("pqh", HeatAndSValue.class),
-  WEATHER("weather", WeatherValue.class);
+  WEATHER("weather", WeatherValue.class),
+  VOLTAGE("v", VoltageValue.class);
 
   private final String scheme;
   private final Class<? extends Value> valueClass;
@@ -57,6 +58,7 @@ public static <V extends Value> Optional<ColumnScheme> parse(Class<V> valueClass
     if (PValue.class.isAssignableFrom(valueClass)) return Optional.of(ACTIVE_POWER);
     if (HeatDemandValue.class.isAssignableFrom(valueClass)) return Optional.of(HEAT_DEMAND);
     if (WeatherValue.class.isAssignableFrom(valueClass)) return Optional.of(WEATHER);
+    if (VoltageValue.class.isAssignableFrom(valueClass)) return Optional.of(VOLTAGE);
     return Optional.empty();
   }
 }

src/main/java/edu/ie3/datamodel/io/processor/EntityProcessor.java

@@ -55,7 +55,7 @@ protected EntityProcessor(Class<? extends T> registeredClass) throws EntityProce
    *     during processing
    */
   public LinkedHashMap<String, String> handleEntity(T entity) throws EntityProcessorException {
-    if (!registeredClass.equals(entity.getClass()))
+    if (!registeredClass.isAssignableFrom(entity.getClass()))
       throw new EntityProcessorException(
           "Cannot process "
               + entity.getClass().getSimpleName()

src/main/java/edu/ie3/datamodel/models/value/VoltageValue.java

@@ -0,0 +1,90 @@
+/*
+ * © 2024. TU Dortmund University,
+ * Institute of Energy Systems, Energy Efficiency and Energy Economics,
+ * Research group Distribution grid planning and operation
+*/
+package edu.ie3.datamodel.models.value;
+
+import static edu.ie3.datamodel.models.StandardUnits.VOLTAGE_ANGLE;
+import static edu.ie3.util.quantities.PowerSystemUnits.DEGREE_GEOM;
+import static edu.ie3.util.quantities.PowerSystemUnits.PU;
+import static java.lang.Math.*;
+
+import java.util.Objects;
+import java.util.Optional;
+import javax.measure.quantity.Angle;
+import javax.measure.quantity.Dimensionless;
+import tech.units.indriya.ComparableQuantity;
+import tech.units.indriya.quantity.Quantities;
+
+/** Describes a voltage value as a pair of magnitude and angle */
+public class VoltageValue implements Value {
+
+  /** Magnitude of the voltage in p.u. */
+  private final ComparableQuantity<Dimensionless> magnitude;
+  /** Angle of the voltage in degree */
+  private final ComparableQuantity<Angle> angle;
+
+  /**
+   * @param magnitude of the voltage in p.u.
+   * @param angleOption option for the angle of this voltage in degree
+   */
+  public VoltageValue(
+      ComparableQuantity<Dimensionless> magnitude,
+      Optional<ComparableQuantity<Angle>> angleOption) {
+    this.magnitude = magnitude;
+    this.angle = angleOption.orElse(Quantities.getQuantity(0.0, VOLTAGE_ANGLE));
+  }
+
+  /**
+   * @param magnitude of the voltage in p.u.
+   * @param angle of the voltage in degree
+   */
+  public VoltageValue(
+      ComparableQuantity<Dimensionless> magnitude, ComparableQuantity<Angle> angle) {
+    this.magnitude = magnitude;
+    this.angle = angle;
+  }
+
+  public Optional<ComparableQuantity<Dimensionless>> getMagnitude() {
+    return Optional.ofNullable(magnitude);
+  }
+
+  public Optional<ComparableQuantity<Angle>> getAngle() {
+    return Optional.ofNullable(angle);
+  }
+
+  public Optional<ComparableQuantity<Dimensionless>> getRealPart() {
+    double mag = magnitude.to(PU).getValue().doubleValue();
+    double ang = angle.to(DEGREE_GEOM).getValue().doubleValue();
+
+    double eInPu = mag * cos(toRadians(ang));
+    return Optional.of(Quantities.getQuantity(eInPu, PU));
+  }
+
+  public Optional<ComparableQuantity<Dimensionless>> getImagPart() {
+    double mag = magnitude.to(PU).getValue().doubleValue();
+    double ang = angle.to(DEGREE_GEOM).getValue().doubleValue();
+
+    double fInPu = mag * sin(toRadians(ang));
+    return Optional.of(Quantities.getQuantity(fInPu, PU));
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    VoltageValue that = (VoltageValue) o;
+    return Objects.equals(magnitude, that.magnitude) && Objects.equals(angle, that.angle);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(magnitude, angle);
+  }
+
+  @Override
+  public String toString() {
+    return "VoltageValue{" + "magnitude=" + magnitude + ", angle=" + angle + '}';
+  }
+}

src/main/java/edu/ie3/datamodel/utils/TimeSeriesUtils.java

@@ -25,7 +25,8 @@ public class TimeSeriesUtils {
           ENERGY_PRICE,
           APPARENT_POWER_AND_HEAT_DEMAND,
           ACTIVE_POWER_AND_HEAT_DEMAND,
-          HEAT_DEMAND);
+          HEAT_DEMAND,
+          VOLTAGE);
 
   /** Private Constructor as this class is not meant to be instantiated */
   private TimeSeriesUtils() {