GridCalEngine 5.1.33__tar.gz → 5.1.34__tar.gz

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Branches/transformer3w.py

@@ -18,9 +18,10 @@
 from typing import Tuple, Union
 import numpy as np
 from GridCalEngine.Devices.Substation.bus import Bus
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Branches.winding import Winding
 from GridCalEngine.Devices.profile import Profile
+from GridCalEngine.enumerations import DeviceType
 
 
 def delta_to_star(z12: float, z23: float, z31: float) -> Tuple[float, float, float]:
@@ -41,7 +42,7 @@ def delta_to_star(z12: float, z23: float, z31: float) -> Tuple[float, float, flo
         return 1e-20, 1e-20, 1e-20
 
 
-class Transformer3W(EditableDevice):
+class Transformer3W(PhysicalDevice):
 
     def __init__(self, idtag: Union[str, None] = None,
                  code: str = '',
@@ -77,7 +78,7 @@ class Transformer3W(EditableDevice):
         :param x: graphical x position (px)
         :param y: graphical y position (px)
         """
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
                                 code=code,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Diagrams/base_diagram.py

@@ -175,6 +175,10 @@ class BaseDiagram:
 
     @property
     def use_flow_based_width(self) -> bool:
+        """
+
+        :return:
+        """
         return self._use_flow_based_width
 
     @use_flow_based_width.setter
@@ -303,7 +307,7 @@ class BaseDiagram:
 
         return group
 
-    def get_properties_dict(self) -> Dict[str, Union[str, int, float, Dict[str, Union[GraphicLocation, MapLocation]]]]:
+    def get_data_dict(self) -> Dict[str, Union[str, int, float, Dict[str, Union[GraphicLocation, MapLocation]]]]:
         """
         get the properties dictionary to save
         :return: dictionary to serialize

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Diagrams/map_diagram.py

@@ -48,12 +48,12 @@ class MapDiagram(BaseDiagram):
 
         self.latitude = latitude  # latitude
 
-    def get_properties_dict(self) -> Dict[str, Union[str, int, float, Dict[str, Union[GraphicLocation, MapLocation]]]]:
+    def get_data_dict(self) -> Dict[str, Union[str, int, float, Dict[str, Union[GraphicLocation, MapLocation]]]]:
         """
         get the properties dictionary to save
         :return: dictionary to serialize
         """
-        data = super().get_properties_dict()
+        data = super().get_data_dict()
         data['tile_source'] = self.tile_source
         data['start_level'] = self.start_level
         data['longitude'] = self.longitude

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Fluid/fluid_injection_template.py

@@ -16,13 +16,13 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 from typing import Union
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Fluid.fluid_node import FluidNode
 from GridCalEngine.Devices.Injections.generator import Generator
 from GridCalEngine.enumerations import BuildStatus, DeviceType
 
 
-class FluidInjectionTemplate(EditableDevice):
+class FluidInjectionTemplate(PhysicalDevice):
 
     def __init__(self,
                  name: str = '',
@@ -46,7 +46,7 @@ class FluidInjectionTemplate(EditableDevice):
         :param device_type: type of machine (turbine, pump, p2x)
         :param build_status: status if the plant is built, planned, etc.
         """
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
                                 code=code,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Fluid/fluid_node.py

@@ -18,13 +18,13 @@
 from typing import Union
 import numpy as np
 
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Substation.bus import Bus
 from GridCalEngine.enumerations import BuildStatus, DeviceType
 from GridCalEngine.Devices.profile import Profile
 
 
-class FluidNode(EditableDevice):
+class FluidNode(PhysicalDevice):
 
     def __init__(self,
                  name: str = '',
@@ -52,7 +52,7 @@ class FluidNode(EditableDevice):
         :param bus: electrical bus they are linked with
         :param build_status
         """
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
                                 code=code,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Fluid/fluid_path.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 import numpy as np
 from typing import Union, TYPE_CHECKING, Tuple
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.enumerations import DeviceType, SubObjectType
 from GridCalEngine.Devices.Fluid.fluid_node import FluidNode
 from GridCalEngine.Devices.Branches.line_locations import LineLocations
@@ -27,7 +27,7 @@ if TYPE_CHECKING:
     from GridCalEngine.Devices.types import CONNECTION_TYPE
 
 
-class FluidPath(EditableDevice):
+class FluidPath(PhysicalDevice):
 
     def __init__(self,
                  name: str = '',
@@ -47,7 +47,7 @@ class FluidPath(EditableDevice):
         :param min_flow: minimum flow (m3/s)
         :param max_flow: maximum flow (m3/s)
         """
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
                                 code=code,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Parents/branch_parent.py

@@ -23,8 +23,8 @@ from GridCalEngine.Devices.Substation.substation import Substation
 from GridCalEngine.Devices.Substation.voltage_level import VoltageLevel
 from GridCalEngine.Devices.Substation.bus import Bus
 from GridCalEngine.Devices.Substation.connectivity_node import ConnectivityNode
-from GridCalEngine.enumerations import BuildStatus
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.enumerations import BuildStatus, DeviceType
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Aggregation.branch_group import BranchGroup
 from GridCalEngine.Devices.profile import Profile
 
@@ -32,7 +32,7 @@ if TYPE_CHECKING:
     from GridCalEngine.Devices.types import CONNECTION_TYPE
 
 
-class BranchParent(EditableDevice):
+class BranchParent(PhysicalDevice):
     """
     This class serves to represent the basic branch
     All other branches inherit from this one
@@ -82,7 +82,7 @@ class BranchParent(EditableDevice):
         :param device_type: device_type (passed on)
         """
 
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
                                 code=code,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Parents/injection_parent.py

@@ -18,7 +18,7 @@
 from typing import Union
 import numpy as np
 
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Associations.association import Associations
 from GridCalEngine.Devices.Substation.bus import Bus
 from GridCalEngine.Devices.Substation.connectivity_node import ConnectivityNode
@@ -27,7 +27,7 @@ from GridCalEngine.basic_structures import CxVec
 from GridCalEngine.Devices.profile import Profile
 
 
-class InjectionParent(EditableDevice):
+class InjectionParent(PhysicalDevice):
     """
     Parent class for Injections
     """
@@ -63,7 +63,7 @@ class InjectionParent(EditableDevice):
         :param device_type: DeviceType
         """
 
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
                                 code=code,

GridCalEngine-5.1.34/GridCalEngine/Devices/Parents/physical_device.py

@@ -0,0 +1,51 @@
+# GridCal
+# Copyright (C) 2015 - 2024 Santiago Peñate Vera
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+from typing import Union
+from GridCalEngine.Devices.Parents.editable_device import EditableDevice
+from GridCalEngine.Devices.Aggregation.modelling_authority import ModellingAuthority
+from GridCalEngine.enumerations import DeviceType
+
+
+class PhysicalDevice(EditableDevice):
+    """
+    Parent class for Injections, Branches, Buses and other physical devices
+    """
+
+    def __init__(self,
+                 name: str,
+                 idtag: Union[str, None],
+                 code: str,
+                 device_type: DeviceType):
+        """
+        PhysicalDevice
+        :param name: Name of the device
+        :param idtag: unique id of the device (if None or "" a new one is generated)
+        :param code: secondary code for compatibility
+        :param device_type: DeviceType
+        """
+
+        EditableDevice.__init__(self,
+                                name=name,
+                                idtag=idtag,
+                                code=code,
+                                device_type=device_type)
+
+        self.modelling_authority: Union[ModellingAuthority, None] = None
+
+        self.register(key='modelling_authority', units='', tpe=DeviceType.ModellingAuthority,
+                      definition='Modelling authority of this asset')

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Substation/bus.py

@@ -19,15 +19,15 @@ from typing import Tuple, Union
 import numpy as np
 import pandas as pd
 from matplotlib import pyplot as plt
-from GridCalEngine.enumerations import BusMode
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.enumerations import BusMode, DeviceType
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Aggregation import Area, Zone, Country
 from GridCalEngine.Devices.Substation.substation import Substation
 from GridCalEngine.Devices.Substation.voltage_level import VoltageLevel
 from GridCalEngine.Devices.profile import Profile
 
 
-class Bus(EditableDevice):
+class Bus(PhysicalDevice):
 
     def __init__(self, name="Bus",
                  idtag=None,
@@ -88,7 +88,7 @@ class Bus(EditableDevice):
         :param Va0: initial solution for the voltage angle (rad)
         """
 
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 idtag=idtag,
                                 code=code,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Substation/busbar.py

@@ -16,12 +16,13 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 from typing import Union
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.enumerations import DeviceType
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Substation.voltage_level import VoltageLevel
 from GridCalEngine.Devices.Substation.connectivity_node import ConnectivityNode
 
 
-class BusBar(EditableDevice):
+class BusBar(PhysicalDevice):
 
     def __init__(self, name='BusBar', idtag: Union[None, str] = None, code: str = '',
                  voltage_level: Union[None, VoltageLevel] = None,
@@ -34,7 +35,7 @@ class BusBar(EditableDevice):
         :param voltage_level: VoltageLevel of this bus bar (optional)
         :param cn: internal Connectivity node, if none a new one is created
         """
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 code=code,
                                 idtag=idtag,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Substation/connectivity_node.py

@@ -19,10 +19,11 @@ from typing import Union
 
 from GridCalEngine.Devices.Substation.voltage_level import VoltageLevel
 from GridCalEngine.Devices.Substation.bus import Bus
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
+from GridCalEngine.enumerations import DeviceType
 
 
-class ConnectivityNode(EditableDevice):
+class ConnectivityNode(PhysicalDevice):
 
     def __init__(self, name='CN',
                  idtag=None,
@@ -43,7 +44,7 @@ class ConnectivityNode(EditableDevice):
         :param internal: Is internal?
         :param Vnom: Nominal voltage in kV
         """
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 code=code,
                                 idtag=idtag,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/Substation/voltage_level.py

@@ -16,12 +16,12 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 from typing import Union
-from GridCalEngine.Devices.Parents.editable_device import DeviceType
-from GridCalEngine.Devices.Parents.editable_device import EditableDevice
+from GridCalEngine.enumerations import DeviceType
+from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Substation.substation import Substation
 
 
-class VoltageLevel(EditableDevice):
+class VoltageLevel(PhysicalDevice):
 
     def __init__(self, name='VoltageLevel', idtag: Union[str, None] = None, code: str = '',
                  Vnom: float = 1.0, substation: Union[None, Substation] = None):
@@ -33,7 +33,7 @@ class VoltageLevel(EditableDevice):
         :param Vnom: Nominal voltage in kV
         :param substation: Substation object (optional)
         """
-        EditableDevice.__init__(self,
+        PhysicalDevice.__init__(self,
                                 name=name,
                                 code=code,
                                 idtag=idtag,

{GridCalEngine-5.1.33 → GridCalEngine-5.1.34}/GridCalEngine/Devices/assets.py

@@ -5326,3 +5326,278 @@ class Assets:
         for key, elm_list in self.template_objects_dict.items():
             for elm in elm_list:
                 self.get_elements_by_type(device_type=elm.device_type).clear()
+
+    def get_dictionary_of_lists(self, elm_type: DeviceType) -> Tuple[
+        ALL_DEV_TYPES, Dict[DeviceType, List[ALL_DEV_TYPES]]]:
+        """
+
+        :param elm_type:
+        :return:
+        """
+        dictionary_of_lists = dict()
+
+        if elm_type == DeviceType.BusDevice:
+            elm = dev.Bus()
+            dictionary_of_lists = {DeviceType.AreaDevice: self.areas,
+                                   DeviceType.ZoneDevice: self.zones,
+                                   DeviceType.SubstationDevice: self.substations,
+                                   DeviceType.VoltageLevelDevice: self.voltage_levels,
+                                   DeviceType.CountryDevice: self.countries,
+                                   DeviceType.ModellingAuthority: self.modelling_authorities,
+                                   }
+
+        elif elm_type == DeviceType.LoadDevice:
+            elm = dev.Load()
+            dictionary_of_lists = {
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.StaticGeneratorDevice:
+            elm = dev.StaticGenerator()
+            dictionary_of_lists = {
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.ControllableShuntDevice:
+            elm = dev.ControllableShunt()
+            dictionary_of_lists = {
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.CurrentInjectionDevice:
+            elm = dev.CurrentInjection()
+            dictionary_of_lists = {
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.GeneratorDevice:
+            elm = dev.Generator()
+            dictionary_of_lists = {DeviceType.Technology: self.technologies,
+                                   DeviceType.FuelDevice: self.fuels,
+                                   DeviceType.EmissionGasDevice: self.emission_gases,
+                                   DeviceType.ModellingAuthority: self.modelling_authorities, }
+
+        elif elm_type == DeviceType.BatteryDevice:
+            elm = dev.Battery()
+            dictionary_of_lists = {
+                DeviceType.Technology: self.technologies,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.ShuntDevice:
+            elm = dev.Shunt()
+            dictionary_of_lists = {
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.ExternalGridDevice:
+            elm = dev.ExternalGrid()
+            dictionary_of_lists = {
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.LineDevice:
+            elm = dev.Line()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.SwitchDevice:
+            elm = dev.Switch()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.Transformer2WDevice:
+            elm = dev.Transformer2W()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.WindingDevice:
+            elm = dev.Winding()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.Transformer3WDevice:
+            elm = dev.Transformer3W()
+            dictionary_of_lists = {
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.HVDCLineDevice:
+            elm = dev.HvdcLine()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.VscDevice:
+            elm = dev.VSC()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.UpfcDevice:
+            elm = dev.UPFC()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.SeriesReactanceDevice:
+            elm = dev.SeriesReactance()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.DCLineDevice:
+            elm = dev.DcLine()
+            dictionary_of_lists = {
+                DeviceType.BranchGroupDevice: self.branch_groups,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.SubstationDevice:
+            elm = dev.Substation()
+            dictionary_of_lists = {
+                DeviceType.CountryDevice: self.get_countries(),
+                DeviceType.CommunityDevice: self.get_communities(),
+                DeviceType.RegionDevice: self.get_regions(),
+                DeviceType.MunicipalityDevice: self.get_municipalities(),
+                DeviceType.AreaDevice: self.get_areas(),
+                DeviceType.ZoneDevice: self.get_zones(),
+            }
+
+        elif elm_type == DeviceType.ConnectivityNodeDevice:
+            elm = dev.ConnectivityNode()
+            dictionary_of_lists = {
+                DeviceType.BusDevice: self.buses,
+                DeviceType.VoltageLevelDevice: self.voltage_levels,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.BusBarDevice:
+            elm = dev.BusBar()
+            dictionary_of_lists = {
+                DeviceType.VoltageLevelDevice: self.voltage_levels,
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.VoltageLevelDevice:
+            elm = dev.VoltageLevel()
+            dictionary_of_lists = {DeviceType.SubstationDevice: self.get_substations(), }
+
+        elif elm_type == DeviceType.AreaDevice:
+            elm = dev.Area()
+
+        elif elm_type == DeviceType.ZoneDevice:
+            elm = dev.Zone()
+            dictionary_of_lists = {DeviceType.AreaDevice: self.get_areas(), }
+
+        elif elm_type == DeviceType.CountryDevice:
+            elm = dev.Country()
+
+        elif elm_type == DeviceType.CommunityDevice:
+            elm = dev.Community()
+            dictionary_of_lists = {DeviceType.CountryDevice: self.get_countries(), }
+
+        elif elm_type == DeviceType.RegionDevice:
+            elm = dev.Region()
+            dictionary_of_lists = {DeviceType.CommunityDevice: self.get_communities(), }
+
+        elif elm_type == DeviceType.MunicipalityDevice:
+            elm = dev.Municipality()
+            dictionary_of_lists = {DeviceType.RegionDevice: self.get_regions(), }
+
+        elif elm_type == DeviceType.ContingencyDevice:
+            elm = dev.Contingency()
+            dictionary_of_lists = {DeviceType.ContingencyGroupDevice: self.get_contingency_groups(), }
+
+        elif elm_type == DeviceType.ContingencyGroupDevice:
+            elm = dev.ContingencyGroup()
+
+        elif elm_type == DeviceType.InvestmentDevice:
+            elm = dev.Investment()
+            dictionary_of_lists = {DeviceType.InvestmentsGroupDevice: self.investments_groups, }
+
+        elif elm_type == DeviceType.InvestmentsGroupDevice:
+            elm = dev.InvestmentsGroup()
+
+        elif elm_type == DeviceType.BranchGroupDevice:
+            elm = dev.BranchGroup()
+
+        elif elm_type == DeviceType.Technology:
+            elm = dev.Technology()
+
+        elif elm_type == DeviceType.FuelDevice:
+            elm = dev.Fuel()
+
+        elif elm_type == DeviceType.EmissionGasDevice:
+            elm = dev.EmissionGas()
+
+        elif elm_type == DeviceType.WireDevice:
+            elm = dev.Wire()
+
+        elif elm_type == DeviceType.OverheadLineTypeDevice:
+            elm = dev.OverheadLineType()
+
+        elif elm_type == DeviceType.SequenceLineDevice:
+            elm = dev.SequenceLineType()
+
+        elif elm_type == DeviceType.UnderGroundLineDevice:
+            elm = dev.UndergroundLineType()
+
+        elif elm_type == DeviceType.TransformerTypeDevice:
+            elm = dev.TransformerType()
+
+        elif elm_type == DeviceType.FluidNodeDevice:
+            elm = dev.FluidNode()
+            dictionary_of_lists = {DeviceType.ModellingAuthority: self.modelling_authorities, }
+
+        elif elm_type == DeviceType.FluidPathDevice:
+            elm = dev.FluidPath()
+            dictionary_of_lists = {
+                DeviceType.FluidNodeDevice: self.get_fluid_nodes(),
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.FluidTurbineDevice:
+            elm = dev.FluidTurbine()
+            dictionary_of_lists = {
+                DeviceType.FluidNodeDevice: self.get_fluid_nodes(),
+                DeviceType.GeneratorDevice: self.get_generators(),
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.FluidPumpDevice:
+            elm = dev.FluidPump()
+            dictionary_of_lists = {
+                DeviceType.FluidNodeDevice: self.get_fluid_nodes(),
+                DeviceType.GeneratorDevice: self.get_generators(),
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.FluidP2XDevice:
+            elm = dev.FluidP2x()
+            dictionary_of_lists = {
+                DeviceType.FluidNodeDevice: self.get_fluid_nodes(),
+                DeviceType.GeneratorDevice: self.get_generators(),
+                DeviceType.ModellingAuthority: self.modelling_authorities,
+            }
+
+        elif elm_type == DeviceType.ModellingAuthority:
+            elm = dev.ModellingAuthority()
+            dictionary_of_lists = dict()
+
+        else:
+            raise Exception(f'elm_type not understood: {elm_type.value}')
+
+        return elm, dictionary_of_lists