GridCalEngine 5.1.16__tar.gz → 5.1.18__tar.gz

{GridCalEngine-5.1.16 → GridCalEngine-5.1.18}/GridCalEngine/Devices/Aggregation/__init__.py

@@ -19,9 +19,6 @@ from GridCalEngine.Devices.Aggregation.contingency import Contingency
 from GridCalEngine.Devices.Aggregation.contingency_group import ContingencyGroup
 from GridCalEngine.Devices.Aggregation.investment import Investment
 from GridCalEngine.Devices.Aggregation.investments_group import InvestmentsGroup
-from GridCalEngine.Devices.Aggregation.technology import Technology
-from GridCalEngine.Devices.Aggregation.fuel import Fuel
-from GridCalEngine.Devices.Aggregation.emission_gas import EmissionGas
 from GridCalEngine.Devices.Aggregation.area import Area
 from GridCalEngine.Devices.Aggregation.zone import Zone
 from GridCalEngine.Devices.Aggregation.country import Country

{GridCalEngine-5.1.16 → GridCalEngine-5.1.18}/GridCalEngine/Devices/Associations/__init__.py

@@ -15,6 +15,7 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
-from GridCalEngine.Devices.Associations.generator_fuel import GeneratorFuel
-from GridCalEngine.Devices.Associations.generator_emission import GeneratorEmission
-from GridCalEngine.Devices.Associations.generator_technology import GeneratorTechnology
+from GridCalEngine.Devices.Associations.association import Association, Associations
+from GridCalEngine.Devices.Associations.fuel import Fuel
+from GridCalEngine.Devices.Associations.emission_gas import EmissionGas
+from GridCalEngine.Devices.Associations.technology import Technology

GridCalEngine-5.1.18/GridCalEngine/Devices/Associations/association.py

@@ -0,0 +1,234 @@
+# 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 __future__ import annotations
+from typing import TYPE_CHECKING, Dict, Union, List, Iterator
+from GridCalEngine.enumerations import DeviceType
+from GridCalEngine.basic_structures import Logger
+
+if TYPE_CHECKING:
+    from GridCalEngine.Devices.types import ASSOCIATION_TYPES, ALL_DEV_TYPES
+
+
+class Association:
+    """
+    GridCal relationship object, this handles the unit of association
+    """
+
+    def __init__(self, api_object: Union[None, ASSOCIATION_TYPES] = None, value: float = 1.0):
+
+        self.api_object: ASSOCIATION_TYPES = api_object
+
+        self.value = value
+
+    def to_dict(self) -> Dict[str, Union[str, float]]:
+        """
+
+        :return:
+        """
+        return {
+            "elm": self.api_object.idtag,
+            "value": self.value
+        }
+
+    def parse(self,
+              data: Dict[str, Union[str, float]],
+              elements_dict: Dict[str, ALL_DEV_TYPES]) -> str:
+        """
+
+        :param data:
+        :param elements_dict:
+        :return:
+        """
+        idtag = data['elm']
+        self.api_object = elements_dict.get(idtag, None)
+        self.value = float(data['value'])
+        return idtag
+
+    def __eq__(self, other: "Association") -> bool:
+        """
+        Equal?
+        :param other:
+        :return:
+        """
+        if self.api_object.idtag != self.api_object.idtag:
+            # Different refference objects
+            return False
+        if self.value != self.value:
+            # different values
+            return False
+
+        return True
+
+
+class Associations:
+    """
+    GridCal associations object, this handless a set of associations
+    """
+
+    def __init__(self, device_type: DeviceType):
+        """
+        Constructor
+        :param device_type: DeviceType
+        """
+        self._data: Dict[str, Association] = dict()
+
+        self._device_type = device_type
+
+    @property
+    def device_type(self) -> DeviceType:
+        """
+        Device Type
+        :return:
+        """
+        return self._device_type
+
+    def add(self, val: Association):
+        """
+        Add Association
+        :param val:
+        :return:
+        """
+        if val.api_object is not None:
+            self._data[val.api_object.idtag] = val
+
+    def add_object(self, api_object: ASSOCIATION_TYPES, val: float) -> Association:
+        """
+        Add association
+        :param api_object:
+        :param val:
+        :return:
+        """
+        assoc = Association(api_object=api_object, value=val)
+        self.add(assoc)
+        return assoc
+
+    def remove(self, val: Association):
+        """
+        Remove Association
+        :param val:
+        :return:
+        """
+        if val.api_object is not None:
+            del self._data[val.api_object.idtag]
+
+    def remove_by_key(self, key: str):
+        """
+        Remove Association by key
+        :param key:
+        :return:
+        """
+        if key in self._data.keys():
+            del self._data[key]
+
+    def at_key(self, key: str) -> Union[Association, None]:
+        """
+        Remove Association by key
+        :param key:
+        :return:
+        """
+        return self._data.get(key, None)
+
+    def to_dict(self) -> List[Dict[str, Union[str, float]]]:
+        """
+        Get dictionary representation of Associations
+        :return:
+        """
+        return [val.to_dict() for _, val in self._data.items()]
+
+    def parse(self,
+              data: List[Dict[str, Union[str, float]]],
+              elements_dict: Dict[str, ALL_DEV_TYPES],
+              logger: Logger,
+              elm_name: str) -> None:
+        """
+        Parse the data generated with to_dict()
+        :param data: Json data
+        :param elements_dict: dictionary of elements of the type self.device_type
+        :param logger: Logger
+        :param elm_name: base element name for reporting
+        """
+
+        for entry in data:
+
+            assoc = Association()
+            associated_idtag = assoc.parse(
+                data=entry,
+                elements_dict=elements_dict
+            )
+
+            if assoc.api_object is not None:
+                # add the entry
+                self.add(assoc)
+            else:
+                logger.add_error(f'Association api_object not found',
+                                 device=elm_name,
+                                 value=associated_idtag)
+
+    def append(self, item: Association) -> None:
+        """
+        Add item
+        :param item:
+        """
+        self.add(item)
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __iter__(self) -> Iterator[Association]:
+        for key, val in self._data.items():
+            yield val
+
+    def __repr__(self) -> str:
+        return repr(self._data)
+
+    def clear(self) -> None:
+        """
+        Clear data
+        """
+        self._data.clear()
+
+    def __eq__(self, other: "Associations") -> bool:
+        """
+        Equal?
+        :param other: Associations
+        :return: is equal?
+        """
+        if not isinstance(other, Associations):
+            return False
+
+        if len(self) != len(other):
+            # different length
+            return False
+
+        for key, val in self._data.items():
+
+            val2 = other._data.get(key, None)
+
+            if val2 is None:
+                # a key was not found, these are not equal
+                return False
+            else:
+                if val != val2:
+                    # the associations are different
+                    return False
+
+        return True
+
+
+
+
+

{GridCalEngine-5.1.16 → GridCalEngine-5.1.18}/GridCalEngine/Devices/Injections/generator.py

@@ -21,7 +21,7 @@ from typing import Union
 from matplotlib import pyplot as plt
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.enumerations import DeviceType, BuildStatus, SubObjectType
-from GridCalEngine.Devices.Aggregation.technology import Technology
+from GridCalEngine.Devices.Associations.association import Associations
 from GridCalEngine.Devices.Parents.generator_parent import GeneratorParent
 from GridCalEngine.Devices.Injections.generator_q_curve import GeneratorQCurve
 from GridCalEngine.Devices.profile import Profile
@@ -50,7 +50,6 @@ class Generator(GeneratorParent):
                  enabled_dispatch=True,
                  mttf: float = 0.0,
                  mttr: float = 0.0,
-                 technology: Technology = None,
                  q_points=None,
                  use_reactive_power_curve=False,
                  r1: float = 1e-20,
@@ -83,7 +82,6 @@ class Generator(GeneratorParent):
         :param enabled_dispatch: Is the generator enabled for OPF?
         :param mttf: Mean time to failure in hours
         :param mttr: Mean time to recovery in hours
-        :param technology:  Instance of technology to use
         :param q_points: list of reactive capability curve points [(P1, Qmin1, Qmax1), (P2, Qmin2, Qmax2), ...]
         :param use_reactive_power_curve: Use the reactive power curve? otherwise use the plain old limits
         :param r1:
@@ -117,8 +115,6 @@ class Generator(GeneratorParent):
                                  build_status=build_status,
                                  device_type=DeviceType.GeneratorDevice)
 
-        self.technology = technology
-
         # is the device active for active power dispatch?
         self.enabled_dispatch = enabled_dispatch
 
@@ -189,6 +185,9 @@ class Generator(GeneratorParent):
         self._Cost2_prof = Profile(default_value=Cost2, data_type=float)
         self._Cost0_prof = Profile(default_value=Cost0, data_type=float)
 
+        self.emissions: Associations = Associations(device_type=DeviceType.EmissionGasDevice)
+        self.fuels: Associations = Associations(device_type=DeviceType.FuelDevice)
+
         # Dynamic vars
         # self.Ra = Ra
         # self.Xa = Xa
@@ -249,6 +248,12 @@ class Generator(GeneratorParent):
 
         self.register(key='enabled_dispatch', units='', tpe=bool, definition='Enabled for dispatch? Used in OPF.')
 
+        self.register(key='emissions', units='', tpe=SubObjectType.Associations,
+                      definition='List of emissions', display=False)
+
+        self.register(key='fuels', units='', tpe=SubObjectType.Associations,
+                      definition='List of fuels', display=False)
+
     @property
     def Pf_prof(self) -> Profile:
         """

{GridCalEngine-5.1.16 → GridCalEngine-5.1.18}/GridCalEngine/Devices/Parents/editable_device.py

@@ -210,7 +210,7 @@ class EditableDevice:
 
         self._name: str = name
 
-        self.code: str = code
+        self._code: str = code
 
         self.device_type: DeviceType = device_type
 
@@ -276,6 +276,22 @@ class EditableDevice:
         """
         self._idtag = parse_idtag(val)
 
+    @property
+    def code(self) -> str:
+        """
+        code getter
+        :return: string, hopefully an UUIDv4
+        """
+        return self._code
+
+    @code.setter
+    def code(self, val: Union[str, None]):
+        """
+        code setter
+        :param val: any string or None
+        """
+        self._code = val
+
     def flatten_idtag(self):
         """
         Remove useless undercore and
@@ -433,6 +449,20 @@ class EditableDevice:
 
         return props, indices
 
+    def get_association_properties(self) -> Tuple[List[GCProp], List[int]]:
+        """
+        Return the list of properties that contain associate another type
+        :return: list of GCProp, list of indices
+        """
+        props = list()
+        indices = list()
+        for i, prop in enumerate(self.property_list):
+            if prop.tpe == SubObjectType.Associations:
+                props.append(prop)
+                indices.append(i)
+
+        return props, indices
+
     def get_snapshot_value(self, prop: GCProp) -> Any:
         """
         Return the stored object value from the property index
@@ -476,6 +506,14 @@ class EditableDevice:
         """
         return self.property_list[property_idx]
 
+    def get_property_by_name(self, prop_name: str) -> GCProp:
+        """
+
+        :param prop_name:
+        :return:
+        """
+        return self.registered_properties[prop_name]
+
     def get_property_value_by_idx(self, property_idx: int, t_idx: Union[None, int]) -> Any:
         """
         Return the stored object value from the property index

{GridCalEngine-5.1.16 → GridCalEngine-5.1.18}/GridCalEngine/Devices/Parents/injection_parent.py

@@ -17,10 +17,12 @@
 
 from typing import Union
 import numpy as np
+
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice
+from GridCalEngine.Devices.Associations.association import Associations
 from GridCalEngine.Devices.Substation.bus import Bus
 from GridCalEngine.Devices.Substation.connectivity_node import ConnectivityNode
-from GridCalEngine.enumerations import BuildStatus, DeviceType
+from GridCalEngine.enumerations import BuildStatus, DeviceType, SubObjectType
 from GridCalEngine.basic_structures import CxVec
 from GridCalEngine.Devices.profile import Profile
 
@@ -89,6 +91,8 @@ class InjectionParent(EditableDevice):
 
         self.build_status = build_status
 
+        self.technologies: Associations = Associations(device_type=DeviceType.Technology)
+
         self.register(key='bus', units='', tpe=DeviceType.BusDevice, definition='Connection bus',
                       editable=False, profile_name="bus_prof")
 
@@ -110,6 +114,9 @@ class InjectionParent(EditableDevice):
         self.register(key='Cost', units='e/MWh', tpe=float, definition='Cost of not served energy. Used in OPF.',
                       profile_name='Cost_prof')
 
+        self.register(key='technologies', units='', tpe=SubObjectType.Associations,
+                      definition='List of technologies', display=False)
+
     @property
     def bus(self) -> Bus:
         """