NREL-ditto 0.0.7__py3-none-any.whl

ditto/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.7"

ditto/enumerations.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class OpenDSSFileTypes(str, Enum):
+    MASTER_FILE = "Master.dss"
+    COORDINATE_FILE = "BusCoords.dss"
+    WIRES_FILE = "WireData.dss"
+    LINE_GEOMETRIES_FILE = "LineGeometry.dss"
+    LINECODES_FILE = "LineCodes.dss"
+    SWITCH_CODES_FILE = "SwitchCodes.dss"
+    FUSE_CODES_FILE = "FuseCodes.dss"
+    TRANSFORMERS_FILE = "Transformers.dss"
+    CAPACITORS_FILE = "Capacitors.dss"
+    LINES_FILE = "Lines.dss"
+    LOADS_FILE = "Loads.dss"
+    SWITCH_FILE = "Switches.dss"
+    FUSE_FILE = "Fuses.dss"
+    REGULATOR_CONTROLLERS_FILE = "RegControllers.dss"

ditto/readers/cim_iec_61968_13/__init__.py

@@ -0,0 +1,31 @@
+from ditto.readers.cim_iec_61968_13.components.distribution_bus import DistributionBusMapper
+from ditto.readers.cim_iec_61968_13.components.distribution_capacitor import (
+    DistributionCapacitorMapper,
+)
+from ditto.readers.cim_iec_61968_13.components.distribution_load import DistributionLoadMapper
+from ditto.readers.cim_iec_61968_13.components.distribution_transformer import (
+    DistributionTransformerMapper,
+)
+from ditto.readers.cim_iec_61968_13.equipment.distribution_transformer_equipment import (
+    DistributionTransformerEquipmentMapper,
+)
+from ditto.readers.cim_iec_61968_13.equipment.matrix_branch_equipment import (
+    MatrixImpedanceBranchEquipmentMapper,
+)
+from ditto.readers.cim_iec_61968_13.components.matrix_branch import MatrixImpedanceBranchMapper
+from ditto.readers.cim_iec_61968_13.components.distribution_voltage_source import (
+    DistributionVoltageSourceMapper,
+)
+from ditto.readers.cim_iec_61968_13.equipment.voltage_source_equipment import (
+    VoltageSourceEquipmentMapper,
+)
+from ditto.readers.cim_iec_61968_13.controllers.regulator_controller import (
+    RegulatorControllerMapper,
+)
+from ditto.readers.cim_iec_61968_13.components.distribution_regulator import (
+    DistributionRegulatorMapper,
+)
+
+from ditto.readers.cim_iec_61968_13.components.matrix_impedance_switch import (
+    MatrixImpedanceSwitchMapper,
+)

ditto/readers/cim_iec_61968_13/cim_mapper.py

@@ -0,0 +1,8 @@
+from abc import ABC
+
+from gdm.distribution import DistributionSystem
+
+
+class CimMapper(ABC):
+    def __init__(self, system: DistributionSystem):
+        self.system = system

ditto/readers/cim_iec_61968_13/common.py

@@ -0,0 +1,3 @@
+from gdm.distribution.enums import Phase
+
+phase_mapper = {"A": Phase.A, "B": Phase.B, "C": Phase.C}

ditto/readers/cim_iec_61968_13/components/distribution_bus.py

@@ -0,0 +1,61 @@
+from gdm.distribution.components import DistributionBus
+from gdm.distribution.common import VoltageLimitSet
+from gdm.quantities import PositiveVoltage
+from infrasys.location import Location
+from gdm.distribution.enums import (
+    VoltageTypes,
+    LimitType,
+)
+
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+from ditto.readers.cim_iec_61968_13.common import phase_mapper
+
+
+class DistributionBusMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        phases = row["phase"].split(",")
+        self.n_phase = len(phases)
+        return DistributionBus(
+            name=self.map_name(row),
+            coordinate=self.map_coordinate(row),
+            rated_voltage=self.map_rated_voltage(row),
+            phases=self.map_phases(row),
+            voltagelimits=self.map_voltagelimits(row),
+            voltage_type=self.map_voltage_type(row),
+        )
+
+    def map_name(self, row):
+        return row["bus"]
+
+    def map_coordinate(self, row):
+        X, Y = row["x"], row["y"]
+        crs = None
+        location = Location(x=X, y=Y, crs=crs)
+        return location
+
+    # Nominal voltage is only defined by transformers
+    def map_rated_voltage(self, row):
+        return PositiveVoltage(float(row["rated_voltage"]) / 1.732, "volt")
+
+    def map_phases(self, row):
+        phases = row["phase"].split(",")
+        all_phases = [phase_mapper[phase] for phase in phases]
+        return all_phases
+
+    def map_voltagelimits(self, row):
+        return [
+            VoltageLimitSet(
+                limit_type=LimitType.MIN,
+                value=PositiveVoltage(float(row["rated_voltage"]) * 0.95, "volt"),
+            ),
+            VoltageLimitSet(
+                limit_type=LimitType.MAX,
+                value=PositiveVoltage(float(row["rated_voltage"]) * 1.05, "volt"),
+            ),
+        ]
+
+    def map_voltage_type(self, row):
+        return VoltageTypes.LINE_TO_GROUND.value

ditto/readers/cim_iec_61968_13/components/distribution_capacitor.py

@@ -0,0 +1,43 @@
+from gdm.distribution.components import DistributionBus, DistributionCapacitor
+
+from ditto.readers.cim_iec_61968_13.equipment.capacitor_equipment import CapacitorEquipmentMapper
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+from ditto.readers.cim_iec_61968_13.common import phase_mapper
+
+
+class DistributionCapacitorMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        return DistributionCapacitor(
+            name=self.map_name(row),
+            bus=self.map_bus(row),
+            phases=self.map_phases(row),
+            controllers=self.map_controllers(row),
+            equipment=self.map_equipment(row),
+        )
+
+    def map_name(self, row):
+        return row["capacitor"]
+
+    def map_bus(self, row):
+        bus_name = row["bus"]
+        bus = self.system.get_component(component_type=DistributionBus, name=bus_name)
+        return bus
+
+    def map_phases(self, row):
+        phases = row["phase"]
+        if phases is None:
+            phases = ["A", "B", "C"]
+        else:
+            phases = phases.split(",")
+        return [phase_mapper[phase] for phase in phases]
+
+    def map_controllers(self, row):
+        return []
+
+    def map_equipment(self, row):
+        mapper = CapacitorEquipmentMapper(self.system)
+        equipment = mapper.parse(row)
+        return equipment

ditto/readers/cim_iec_61968_13/components/distribution_load.py

@@ -0,0 +1,48 @@
+from gdm.distribution.components import DistributionLoad, DistributionBus
+
+from ditto.readers.cim_iec_61968_13.equipment.load_equipment import LoadEquipmentMapper
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+from ditto.readers.cim_iec_61968_13.common import phase_mapper
+
+
+class DistributionLoadMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        return DistributionLoad(
+            name=self.map_name(row),
+            bus=self.map_bus(row),
+            phases=self.map_phases(row),
+            equipment=self.map_equipment(row),
+        )
+
+    def map_name(self, row):
+        return row["load"]
+
+    def map_bus(self, row):
+        bus_name = row["bus"]
+        bus = self.system.get_component(component_type=DistributionBus, name=bus_name)
+        return bus
+
+    def map_phases(self, row):
+        bus_name = row["bus"]
+        bus = self.system.get_component(component_type=DistributionBus, name=bus_name)
+        phases = row["phase"]
+
+        if phases is None:
+            phases = ["A", "B", "C"]
+        else:
+            phases = phases.split(",")
+        phases = [phase_mapper[phase] for phase in phases]
+
+        if row["grounded"] == "false" and len(phases) == 1:
+            diff = list(set(bus.phases).difference(phases))
+            if diff:
+                phases.append(sorted(diff)[0].value)
+        return phases
+
+    def map_equipment(self, row):
+        mapper = LoadEquipmentMapper(self.system)
+        equipment = mapper.parse(row)
+        return equipment

ditto/readers/cim_iec_61968_13/components/distribution_regulator.py

@@ -0,0 +1,56 @@
+from gdm.distribution.components import DistributionBus, DistributionRegulator
+from gdm.distribution.controllers import RegulatorController
+from gdm.distribution.enums import Phase
+
+from ditto.readers.cim_iec_61968_13.equipment.distribution_transformer_equipment import (
+    DistributionTransformerEquipmentMapper,
+)
+
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+from ditto.readers.cim_iec_61968_13.common import phase_mapper
+
+
+class DistributionRegulatorMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        return DistributionRegulator(
+            name=self.map_name(row),
+            buses=self.map_bus(row),
+            equipment=self.map_equipment(row),
+            winding_phases=self.map_winding_phases(row),
+            controllers=self.map_controllers(row),
+        )
+
+    def map_name(self, row):
+        return row["xfmr"]
+
+    def map_winding_phases(self, row):
+        if "wdg_1_phase" in row:
+            phase_1 = [phase_mapper[phs] for phs in row["wdg_1_phase"].replace("N", "")]
+        else:
+            phase_1 = [Phase.A, Phase.B, Phase.C]
+
+        if "wdg_2_phase" in row:
+            phase_2 = [phase_mapper[phs] for phs in row["wdg_2_phase"].replace("N", "")]
+        else:
+            phase_2 = [Phase.A, Phase.B, Phase.C]
+
+        return [phase_1, phase_2]
+
+    def map_bus(self, row):
+        bus_1_name = row["bus_1"]
+        bus_2_name = row["bus_2"]
+        bus_1 = self.system.get_component(DistributionBus, bus_1_name)
+        bus_2 = self.system.get_component(DistributionBus, bus_2_name)
+        return [bus_1, bus_2]
+
+    def map_equipment(self, row):
+        xfmr_equip_mapper = DistributionTransformerEquipmentMapper(self.system)
+        xfmr_equip = xfmr_equip_mapper.parse(row)
+        return xfmr_equip
+
+    def map_controllers(self, row):
+        reg_controllers = self.system.get_component(RegulatorController, row["xfmr"])
+        return [reg_controllers]

ditto/readers/cim_iec_61968_13/components/distribution_transformer.py

@@ -0,0 +1,38 @@
+from gdm.distribution.components import DistributionBus, DistributionTransformer
+from gdm.distribution.enums import Phase
+
+from ditto.readers.cim_iec_61968_13.equipment.distribution_transformer_equipment import (
+    DistributionTransformerEquipmentMapper,
+)
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+
+
+class DistributionTransformerMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        return DistributionTransformer(
+            name=self.map_name(row),
+            buses=self.map_bus(row),
+            equipment=self.map_equipment(row),
+            winding_phases=self.map_winding_phases(row),
+        )
+
+    def map_name(self, row):
+        return row["xfmr"]
+
+    def map_winding_phases(self, row):
+        return [[Phase.A, Phase.B, Phase.C], [Phase.A, Phase.B, Phase.C]]
+
+    def map_bus(self, row):
+        bus_1_name = row["bus_1"]
+        bus_2_name = row["bus_2"]
+        bus_1 = self.system.get_component(DistributionBus, bus_1_name)
+        bus_2 = self.system.get_component(DistributionBus, bus_2_name)
+        return [bus_1, bus_2]
+
+    def map_equipment(self, row):
+        xfmr_equip_mapper = DistributionTransformerEquipmentMapper(self.system)
+        xfmr_equip = xfmr_equip_mapper.parse(row)
+        return xfmr_equip

ditto/readers/cim_iec_61968_13/components/distribution_voltage_source.py

@@ -0,0 +1,36 @@
+from gdm.distribution.components import DistributionBus, DistributionVoltageSource
+
+from ditto.readers.cim_iec_61968_13.equipment.voltage_source_equipment import (
+    VoltageSourceEquipmentMapper,
+)
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+from ditto.readers.cim_iec_61968_13.common import phase_mapper
+
+
+class DistributionVoltageSourceMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        return DistributionVoltageSource(
+            name=self.map_name(row),
+            bus=self.map_bus(row),
+            phases=self.map_phases(),
+            equipment=self.map_equipment(row),
+        )
+
+    def map_name(self, row):
+        return row["source"]
+
+    def map_bus(self, row):
+        bus_name = row["bus"]
+        bus = self.system.get_component(component_type=DistributionBus, name=bus_name)
+        return bus
+
+    def map_phases(self):
+        return [phase_mapper[phase] for phase in ["A", "B", "C"]]
+
+    def map_equipment(self, row):
+        mapper = VoltageSourceEquipmentMapper(self.system)
+        equipment = mapper.parse(row)
+        return equipment

ditto/readers/cim_iec_61968_13/components/matrix_branch.py

@@ -0,0 +1,42 @@
+from gdm.distribution.components import MatrixImpedanceBranch, DistributionBus
+from gdm.distribution.equipment import MatrixImpedanceBranchEquipment
+from gdm.quantities import PositiveDistance
+
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+from ditto.readers.cim_iec_61968_13.common import phase_mapper
+
+
+class MatrixImpedanceBranchMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        return MatrixImpedanceBranch(
+            name=self.map_name(row),
+            buses=self.map_buses(row),
+            length=self.map_length(row),
+            phases=self.map_phases(row),
+            equipment=self.map_equipment(row),
+        )
+
+    def map_name(self, row):
+        return row["line"]
+
+    def map_buses(self, row):
+        bus_1_name = row["bus_1"]
+        bus_1 = self.system.get_component(DistributionBus, bus_1_name)
+        bus_2_name = row["bus_2"]
+        bus_2 = self.system.get_component(DistributionBus, bus_2_name)
+        return [bus_1, bus_2]
+
+    def map_length(self, row):
+        length = float(row["length"])
+        return PositiveDistance(length, "m")
+
+    def map_phases(self, row):
+        phases = row["phases_1"].split(",")
+        return [phase_mapper[phase] for phase in phases]
+
+    def map_equipment(self, row):
+        equipment = self.system.get_component(MatrixImpedanceBranchEquipment, row["line_code"])
+        return equipment

ditto/readers/cim_iec_61968_13/components/matrix_impedance_switch.py

@@ -0,0 +1,63 @@
+from gdm.distribution.components import MatrixImpedanceSwitch, DistributionBus
+from gdm.quantities import PositiveDistance
+from gdm.distribution.equipment import (
+    MatrixImpedanceSwitchEquipment,
+    MatrixImpedanceBranchEquipment,
+)
+
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+
+
+class MatrixImpedanceSwitchMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        self.bus_2 = self.system.get_component(DistributionBus, row["bus_2"])
+        self.n_phases = len(self.bus_2.phases)
+
+        return MatrixImpedanceSwitch(
+            name=self.map_name(row),
+            buses=self.map_buses(row),
+            length=PositiveDistance(1, "m"),
+            phases=self.map_phases(row),
+            equipment=self.map_equipment(row),
+            is_closed=self.map_is_closed(row),
+        )
+
+    def map_is_closed(self, row):
+        state = True if row["is_open"] == "false" else False
+        return [state] * 3
+
+    def map_name(self, row):
+        return row["switch_name"]
+
+    def map_buses(self, row):
+        bus_1_name = row["bus_1"]
+        bus_1 = self.system.get_component(DistributionBus, bus_1_name)
+        bus_2_name = row["bus_2"]
+        bus_2 = self.system.get_component(DistributionBus, bus_2_name)
+        return [bus_1, bus_2]
+
+    def map_length(self, row):
+        length = float(row["length"])
+        return PositiveDistance(length, "m")
+
+    def map_phases(self, row):
+        return self.bus_2.phases
+
+    def map_equipment(self, row):
+        equipments: list[MatrixImpedanceBranchEquipment] = list(
+            self.system.get_components(
+                MatrixImpedanceBranchEquipment,
+                filter_func=lambda x: len(x.r_matrix) == self.n_phases,
+            )
+        )
+        if len(equipments):
+            model_dict = equipments[0].model_dump()
+            equipment = MatrixImpedanceSwitchEquipment(**model_dict)
+            return equipment
+        else:
+            raise Exception(
+                "No Matrix Impedance Branch Equipment found with {} phases".format(self.n_phases)
+            )

ditto/readers/cim_iec_61968_13/controllers/regulator_controller.py

@@ -0,0 +1,77 @@
+from gdm.distribution.controllers import RegulatorController
+from gdm.distribution.components import DistributionBus
+from gdm.quantities import PositiveVoltage
+from infrasys.quantities import Time
+
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+from ditto.readers.cim_iec_61968_13.common import phase_mapper
+
+
+class RegulatorControllerMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        return RegulatorController(
+            name=self.map_name(row),
+            delay=self.map_delay(row),
+            v_setpoint=self.map_vsetpoint(row),
+            min_v_limit=self.min_v_limit(row),
+            max_v_limit=self.max_v_limit(row),
+            pt_ratio=self.map_pt_ratio(row),
+            use_ldc=self.map_use_ldc(row),
+            is_reversible=self.map_is_reversible(row),
+            ldc_R=self.map_ldc_R(row),
+            ldc_X=self.map_ldc_X(row),
+            ct_primary=self.map_ct_primary(row),
+            max_step=self.map_max_step(row),
+            bandwidth=self.map_bandwidth(row),
+            controlled_bus=self.map_controlled_bus(row),
+            controlled_phase=self.map_controlled_phase(row),
+        )
+
+    def map_name(self, row):
+        return row["regulator"]
+
+    def map_use_ldc(self, row):
+        return row["ldc"]
+
+    def map_is_reversible(self, row):
+        return row["reversible"]
+
+    def map_controlled_bus(self, row):
+        bus_name = row["bus"]
+        return self.system.get_component(component_type=DistributionBus, name=bus_name)
+
+    def map_controlled_phase(self, row):
+        return phase_mapper[row["phase"]]
+
+    def map_delay(self, row):
+        return Time(float(row["initial_delay"]), "second")
+
+    def map_vsetpoint(self, row):
+        return PositiveVoltage(float(row["target"]), "volt")
+
+    def min_v_limit(self, row):
+        return PositiveVoltage(float(row["min_voltage"]), "volt")
+
+    def max_v_limit(self, row):
+        return PositiveVoltage(float(row["max_voltage"]), "volt")
+
+    def map_pt_ratio(self, row):
+        return float(row["pt_ratio"])
+
+    def map_ldc_R(self, row):
+        return float(row["line_drop_r"])
+
+    def map_ldc_X(self, row):
+        return float(row["line_drop_x"])
+
+    def map_ct_primary(self, row):
+        return float(row["ct_rating"])
+
+    def map_max_step(self, row):
+        return 5
+
+    def map_bandwidth(self, row):
+        return PositiveVoltage(float(row["deadband"]), "volt")

ditto/readers/cim_iec_61968_13/equipment/capacitor_equipment.py

@@ -0,0 +1,94 @@
+from gdm.quantities import PositiveReactivePower, PositiveResistance, PositiveReactance
+from gdm.distribution.equipment.phase_capacitor_equipment import PhaseCapacitorEquipment
+from gdm.distribution.equipment.capacitor_equipment import CapacitorEquipment
+from gdm.distribution.enums import ConnectionType, VoltageTypes
+from gdm.quantities import PositiveVoltage
+
+from ditto.readers.cim_iec_61968_13.cim_mapper import CimMapper
+
+
+class CapacitorEquipmentMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row):
+        phases = row["phase"]
+        if phases is None:
+            self.phases = ["A", "B", "C"]
+        else:
+            self.phases = phases.split(",")
+
+        return CapacitorEquipment(
+            name=self.map_name(row),
+            phase_capacitors=self.map_phase_capacitors(row),
+            connection_type=self.map_connection_type(row),
+            rated_voltage=self.map_rated_voltage(row),
+            voltage_type=self.map_voltage_type(),
+        )
+
+    def map_name(self, row):
+        return row["capacitor"] + "_equipment"
+
+    def map_voltage_type(self):
+        n_phases = len(self.phases)
+        return VoltageTypes.LINE_TO_LINE if n_phases == 3 else VoltageTypes.LINE_TO_LINE
+
+    def map_rated_voltage(self, row):
+        return PositiveVoltage(float(row["rated_voltage"]), "volt")
+
+    def map_phase_capacitors(self, row):
+        phase_loads = []
+        n_phases = len(self.phases)
+        voltage = (
+            float(row["rated_voltage"]) if n_phases == 3 else float(row["rated_voltage"]) / 1.732
+        )
+        b1 = float(row["b1"])
+        var = voltage**2 * b1
+        var_per_phase = var / n_phases
+        for phase in self.phases:
+            if b1 > 0:
+                mapper = PhaseCapacitorEquipmentMapper(self.system)
+                phase_load = mapper.parse(row, var_per_phase, phase)
+                phase_loads.append(phase_load)
+        return phase_loads
+
+    def map_connection_type(self, row):
+        return ConnectionType.DELTA if row["conn"] == "D" else ConnectionType.STAR
+
+
+class PhaseCapacitorEquipmentMapper(CimMapper):
+    def __init__(self, system):
+        super().__init__(system)
+
+    def parse(self, row, var_per_phase, phase):
+        return PhaseCapacitorEquipment(
+            name=self.map_name(row, phase),
+            resistance=self.map_resistance(),
+            reactance=self.map_reactance(),
+            rated_reactive_power=self.map_rated_reactive_power(var_per_phase),
+            num_banks_on=self.map_num_banks_on(row),
+            num_banks=self.map_num_banks(row),
+        )
+
+    def map_name(self, row, phase):
+        return row["capacitor"] + "_phase_capacitor_equipment_" + phase
+
+    # Resistance and Reactance not included for capacitors
+    def map_resistance(self):
+        return PositiveResistance(0, "ohm")
+
+    # Resistance and Reactance not included for capacitors
+    def map_reactance(self):
+        return PositiveReactance(0, "ohm")
+
+    # TODO: This doesn't make sense. We should have fixed and switched values
+    def map_rated_reactive_power(self, var_per_phase):
+        return PositiveReactivePower(var_per_phase, "var")
+
+    # TODO: This doesn't make sense. This should indicate if the bank is switched
+    def map_num_banks_on(self, row):
+        return row["steps"]
+
+    # TODO: This doesn't make sense. This should indicate how many banks are switched
+    def map_num_banks(self, row):
+        return row["steps"]