GridCalEngine 5.0.0a18__tar.gz → 5.0.0a19__tar.gz

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Compilers/circuit_to_bentayga.py

@@ -694,11 +694,9 @@ def bentayga_linear_matrices(circuit: MultiCircuit, distributed_slack=False):
 def translate_bentayga_pf_results(grid: MultiCircuit, res) -> PowerFlowResults:
     results = PowerFlowResults(n=grid.get_bus_number(),
                                m=grid.get_branch_number_wo_hvdc(),
-                               n_tr=grid.get_transformers2w_number(),
                                n_hvdc=grid.get_hvdc_number(),
                                bus_names=res.names,
                                branch_names=res.names,
-                               transformer_names=[],
                                hvdc_names=res.hvdc_names,
                                bus_types=res.bus_types)
 

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Compilers/circuit_to_data.py

@@ -292,8 +292,7 @@ def get_generator_data(circuit: MultiCircuit,
         data.names[k] = elm.name
         data.idtag[k] = elm.idtag
 
-        data.qmin[k] = elm.Qmin
-        data.qmax[k] = elm.Qmax
+
         data.controllable[k] = elm.is_controlled
         data.installed_p[k] = elm.Snom
 
@@ -363,6 +362,14 @@ def get_generator_data(circuit: MultiCircuit,
                     elif elm.Vset != Vbus[i]:
                         logger.add_error('Different set points', elm.bus.name, elm.Vset, Vbus[i])
 
+        # reactive power limits, for the given power value
+        if elm.use_reactive_power_curve:
+            data.qmin[k] = elm.q_curve.get_qmin(data.p[i])
+            data.qmax[k] = elm.q_curve.get_qmax(data.p[i])
+        else:
+            data.qmin[k] = elm.Qmin
+            data.qmax[k] = elm.Qmax
+
         data.C_bus_elm[i, k] = 1
 
     return data
@@ -402,9 +409,6 @@ def get_battery_data(circuit: MultiCircuit,
         data.names[k] = elm.name
         data.idtag[k] = elm.idtag
 
-        data.qmin[k] = elm.Qmin
-        data.qmax[k] = elm.Qmax
-
         data.controllable[k] = elm.is_controlled
         data.installed_p[k] = elm.Snom
 
@@ -481,6 +485,14 @@ def get_battery_data(circuit: MultiCircuit,
                     elif elm.Vset != Vbus[i]:
                         logger.add_error('Different set points', elm.bus.name, elm.Vset, Vbus[i])
 
+        # reactive power limits, for the given power value
+        if elm.use_reactive_power_curve:
+            data.qmin[k] = elm.q_curve.get_qmin(data.p[i])
+            data.qmax[k] = elm.q_curve.get_qmax(data.p[i])
+        else:
+            data.qmin[k] = elm.Qmin
+            data.qmax[k] = elm.Qmax
+
         data.C_bus_elm[i, k] = 1
 
     return data

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Compilers/circuit_to_newton_pa.py

@@ -1130,8 +1130,8 @@ def get_newton_pa_linear_opf_options(opf_opt: "OptimalPowerFlowOptions",
                      bs.TimeGrouping.Monthly: npa.TimeGrouping.Monthly,
                      bs.TimeGrouping.Hourly: npa.TimeGrouping.Hourly}
 
-    opt = npa.LinearOpfOptions()
-    opt.solver = solver_dict[opf_opt.mip_solver]
+    opt = npa.LinearOpfOptions(solver=solver_dict[opf_opt.mip_solver])
+    # opt.solver = solver_dict[opf_opt.mip_solver]
     opt.grouping = grouping_dict[opf_opt.grouping]
     opt.unit_commitment = False
     opt.compute_flows = opf_opt.zonal_grouping == ZonalGrouping.NoGrouping
@@ -1434,7 +1434,8 @@ def translate_newton_pa_opf_results(grid: MultiCircuit, res: "npa.NonlinearOpfRe
                                       F=res.F,
                                       T=res.T,
                                       F_hvdc=res.hvdc_F,
-                                      T_hvdc=res.hvdc_T)
+                                      T_hvdc=res.hvdc_T,
+                                      bus_area_indices=grid.get_bus_area_indices())
 
     results.Sbus = res.Scalc[0, :],
     results.voltage = res.voltage[0, :],

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Devices/Branches/__init__.py

@@ -16,7 +16,7 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 
-from GridCalEngine.Core.Devices.Branches.branch import Branch, BranchTemplate
+from GridCalEngine.Core.Devices.Branches.branch import Branch, BranchTemplate, BranchType
 from GridCalEngine.Core.Devices.Branches.dc_line import DcLine
 from GridCalEngine.Core.Devices.Branches.line import Line
 from GridCalEngine.Core.Devices.Branches.hvdc_line import HvdcLine

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Devices/Diagrams/base_diagram.py

@@ -29,7 +29,7 @@ class PointsGroup:
     Diagram
     """
 
-    def __init__(self, name=''):
+    def __init__(self, name: str = '') -> None:
         """
 
         :param name: Diagram name
@@ -76,7 +76,8 @@ class PointsGroup:
 
         return points
 
-    def parse_data(self, data: Dict[str, Dict[str, Union[int, float, List[Tuple[float, float]]]]],
+    def parse_data(self,
+                   data: Dict[str, Dict[str, Union[int, float, List[Tuple[float, float]]]]],
                    obj_dict: Dict[str, EditableDevice]):
         """
         Parse file data ito this class
@@ -176,10 +177,10 @@ class BaseDiagram:
             # search for the device idtag and return the location, if not found return None
             return group.query_point(device)
 
-    def get_properties_dict(self) -> Dict[str, Dict[str, Union[GraphicLocation, MapLocation]]]:
+    def get_properties_dict(self) -> Dict[str, Union[str, int, float, Dict[str,  Union[GraphicLocation, MapLocation]]]]:
         """
-
-        :return:
+        get the properties dictionary to save
+        :return: dictionary to serialize
         """
         data = {category: group.get_dict() for category, group in self.data.items()}
 
@@ -205,8 +206,7 @@ class BaseDiagram:
         for category, loc_dict in data['data'].items():
 
             points_group = PointsGroup(name=category)
-            points_group.parse_data(data=loc_dict,
-                                    obj_dict=obj_dict.get(category, dict()))
+            points_group.parse_data(data=loc_dict, obj_dict=obj_dict.get(category, dict()))
             self.data[category] = points_group
 
     def build_graph(self):

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Devices/Diagrams/graphic_location.py

@@ -33,7 +33,7 @@ class GraphicLocation:
                  api_object: EditableDevice = None,
                  graphic_object: object = None):
         """
-
+        GraphicLocation
         :param x: x position (px)
         :param y: y position (px)
         :param h: height (px)

GridCalEngine-5.0.0a19/GridCalEngine/Core/Devices/Diagrams/map_diagram.py

@@ -0,0 +1,75 @@
+# GridCal
+# Copyright (C) 2015 - 2023 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 Dict, Union, List, Tuple
+from GridCalEngine.Core.Devices.Diagrams.base_diagram import BaseDiagram, PointsGroup
+from GridCalEngine.Core.Devices.Diagrams.graphic_location import GraphicLocation
+from GridCalEngine.Core.Devices.Diagrams.map_location import MapLocation
+from GridCalEngine.Core.Devices.editable_device import EditableDevice
+from GridCalEngine.enumerations import DiagramType, DeviceType
+
+
+class MapDiagram(BaseDiagram):
+    """
+    MapDiagram
+    """
+
+    def __init__(self, idtag: Union[None, str] = None, name: str = '',
+                 tile_source: str = '', start_level: int = 11,
+                 longitude: float = -15.41, latitude: float = 40.11) -> None:
+        """
+        MapDiagram
+        :param idtag: uuid
+        :param name: name of the diagram
+        :param tile_source: tiles' source
+        :param start_level: zoom level
+        """
+        BaseDiagram.__init__(self, idtag=idtag, name=name, diagram_type=DiagramType.SubstationLineMap)
+
+        self.tile_source = tile_source
+
+        self.start_level = start_level
+
+        self.longitude = longitude  # longitude
+
+        self.latitude = latitude  # latitude
+
+    def get_properties_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['tile_source'] = self.tile_source
+        data['start_level'] = self.start_level
+        data['longitude'] = self.longitude
+        data['latitude'] = self.latitude
+        return data
+
+    def parse_data(self,
+                   data: Dict[str, Dict[str, Dict[str, Union[int, float]]]],
+                   obj_dict: Dict[str, Dict[str, EditableDevice]]):
+        """
+        Parse file data ito this class
+        :param data: json dictionary
+        :param obj_dict: dictionary of circuit objects by type to fincd the api objects back from file loading
+        """
+        super().parse_data(data=data, obj_dict=obj_dict)
+
+        self.tile_source = data.get('tile_source', '')
+        self.start_level = data.get('start_level', 11)
+        self.longitude = data.get('longitude', -15.41)
+        self.latitude = data.get('latitude', 40.11)

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Devices/Injections/__init__.py

@@ -21,3 +21,4 @@ from GridCalEngine.Core.Devices.Injections.generator import Generator
 from GridCalEngine.Core.Devices.Injections.load import Load
 from GridCalEngine.Core.Devices.Injections.shunt import Shunt
 from GridCalEngine.Core.Devices.Injections.static_generator import StaticGenerator
+from GridCalEngine.Core.Devices.Injections.generator_q_curve import GeneratorQCurve

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Devices/Injections/generator.py

@@ -23,70 +23,7 @@ from GridCalEngine.basic_structures import Logger, Vec, Mat
 from GridCalEngine.enumerations import DeviceType, BuildStatus
 from GridCalEngine.Core.Devices.Aggregation.technology import Technology
 from GridCalEngine.Core.Devices.Injections.injection_template import InjectionTemplate
-
-
-def make_default_q_curve(Snom: float, Qmin: float, Qmax: float, n: int = 3) -> Mat:
-    """
-    Compute the generator capability curve
-    :param Snom: Nominal power
-    :param Qmin: Minimum reactive power
-    :param Qmax: Maximum reactive power
-    :param n: number of points, at least 3
-    :return: Array of points [(P1, Qmin1, Qmax1), (P2, Qmin2, Qmax2), ...]
-    """
-    assert (n > 2)
-    pts = np.zeros((n, 3))
-    s2 = Snom * Snom
-
-    Qmax2 = Qmax if Qmax < Snom else Snom
-    Qmin2 = Qmin if Qmin > -Snom else -Snom
-
-    # Compute the intersections of the Qlimits with the natural curve
-    p0_max = np.sqrt(s2 - Qmax2 * Qmax2)
-    p0_min = np.sqrt(s2 - Qmin2 * Qmin2)
-    p0 = min(p0_max, p0_min)  # pick the lower limit as the starting point for sampling
-
-    pts[1:, 0] = np.linspace(p0, Snom, n - 1)
-    pts[0, 0] = 0
-    pts[0, 1] = Qmin2
-    pts[0, 2] = Qmax2
-
-    for i in range(1, n):
-        p2 = pts[i, 0] * pts[i, 0]  # P^2
-        q = np.sqrt(s2 - p2)  # point that naturally matches Q = sqrt(S^2 - P^2)
-
-        # assign the natural point if it does not violates the limits imposes, else set the limit
-        qmin = -q if -q > Qmin2 else Qmin2
-        qmax = q if q < Qmax2 else Qmax2
-
-        # Enforce that Qmax > Qmin
-        if qmax < qmin:
-            qmax = qmin
-        if qmin > qmax:
-            qmin = qmax
-
-        # Assign the points
-        pts[i, 1] = qmin
-        pts[i, 2] = qmax
-
-    return pts
-
-
-def get_q_limits(q_points: Mat, p: Vec) -> Tuple[Vec, Vec]:
-    """
-    Get the reactive power limits
-    :param q_points: Array of points [(P1, Qmin1, Qmax1), (P2, Qmin2, Qmax2), ...]
-    :param p: active power value (or array)
-    :return:
-    """
-    all_p = q_points[:, 0]
-    all_qmin = q_points[:, 1]
-    all_qmax = q_points[:, 2]
-
-    qmin = np.interp(p, all_p, all_qmin)
-    qmax = np.interp(p, all_p, all_qmax)
-
-    return qmin, qmax
+from GridCalEngine.Core.Devices.Injections.generator_q_curve import GeneratorQCurve
 
 
 class Generator(InjectionTemplate):
@@ -246,11 +183,14 @@ class Generator(InjectionTemplate):
         # Maximum reactive power in MVAr
         self.qmax_set = Qmax
 
+        # declare the generation curve
+        self.q_curve = GeneratorQCurve()
+
         if q_points is not None:
-            self.q_points = np.array(q_points)
+            self.q_curve.set_data(np.array(q_points))
             self.custom_q_points = True
         else:
-            self.q_points = make_default_q_curve(self.Snom, self.qmin_set, self.qmax_set)
+            self.q_curve.make_default_q_curve(self.Snom, self.qmin_set, self.qmax_set, n=1)
             self.custom_q_points = False
 
         self.Cost2 = 0.0  # Cost of operation €/MW²
@@ -298,6 +238,9 @@ class Generator(InjectionTemplate):
         self.register(key='Qmax', units='MVAr', tpe=float, definition='Maximum reactive power.')
         self.register(key='use_reactive_power_curve', units='', tpe=bool,
                       definition='Use the reactive power capability curve?')
+        self.register(key='q_curve', units='MVAr', tpe=DeviceType.GeneratorQCurve,
+                      definition='Capability curve data (double click on the generator to edit)',
+                      editable=False, display=False)
         self.register(key='Pmin', units='MW', tpe=float, definition='Minimum active power. Used in OPF.')
         self.register(key='Pmax', units='MW', tpe=float, definition='Maximum active power. Used in OPF.')
         self.register(key='R1', units='p.u.', tpe=float, definition='Total positive sequence resistance.')
@@ -429,6 +372,8 @@ class Generator(InjectionTemplate):
                     'snom': self.Snom,
                     'qmin': self.Qmin,
                     'qmax': self.Qmax,
+                    'q_curve': self.q_curve.str(),
+
                     'pmin': self.Pmin,
                     'pmax': self.Pmax,
                     'cost2': self.Cost2,
@@ -558,12 +503,7 @@ class Generator(InjectionTemplate):
         Return the reactive power upper limit
         :return: value
         """
-        if self.use_reactive_power_curve:
-            all_p = self.q_points[:, 0]
-            all_qmax = self.q_points[:, 2]
-            return np.interp(self.P, all_p, all_qmax)
-        else:
-            return self.qmax_set
+        return self.qmax_set
 
     @Qmax.setter
     def Qmax(self, val):
@@ -575,12 +515,7 @@ class Generator(InjectionTemplate):
         Return the reactive power lower limit
         :return: value
         """
-        if self.use_reactive_power_curve:
-            all_p = self.q_points[:, 0]
-            all_qmin = self.q_points[:, 1]
-            return np.interp(self.P, all_p, all_qmin)
-        else:
-            return self.qmin_set
+        return self.qmin_set
 
     @Qmin.setter
     def Qmin(self, val):
@@ -602,5 +537,5 @@ class Generator(InjectionTemplate):
         :param val: float value
         """
         self._Snom = val
-        if not self.custom_q_points:
-            self.q_points = make_default_q_curve(self._Snom, self.qmin_set, self.qmax_set)
+        # if not self.custom_q_points:
+        #     self.q_curve.make_default_q_curve(self._Snom, self.qmin_set, self.qmax_set)

GridCalEngine-5.0.0a19/GridCalEngine/Core/Devices/Injections/generator_q_curve.py

@@ -0,0 +1,219 @@
+# GridCal
+# Copyright (C) 2015 - 2023 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.
+import json
+import numpy as np
+from typing import Tuple
+from matplotlib.pyplot import axis
+from matplotlib import pyplot as plt
+from GridCalEngine.basic_structures import Mat
+
+
+class GeneratorQCurve:
+    """
+    GeneratorQCurve
+    """
+
+    def __init__(self):
+
+        # Array of points [(P1, Qmin1, Qmax1), (P2, Qmin2, Qmax2), ...]
+        self._q_points: Mat = np.zeros((0, 3))
+
+    def set_data(self, data: Mat):
+        """
+        Set the data
+        :param data: numpy array with [(P1, Qmin1, Qmax1), (P2, Qmin2, Qmax2), ...], must have 3 rows or more
+        """
+        assert data.shape[1] == 3  # must have exactly 3 columns: P, Qmin, Qmax
+        assert data.shape[0] > 0  # must have at leat one point
+        self._q_points = data
+
+    def get_data(self):
+        return self._q_points
+
+    def get_data_by_type(self):
+
+        return self._q_points[:, 0], self._q_points[:, 1], self._q_points[:, 2]
+
+    def make_default_q_curve(self, Snom: float, Qmin: float, Qmax: float, n: int = 3):
+        """
+        Compute the theoretical generator capability curve
+        :param Snom: Nominal power
+        :param Qmin: Minimum reactive power
+        :param Qmax: Maximum reactive power
+        :param n: number of points, at least 3
+        """
+        self._q_points = np.zeros((n, 3))
+
+        if n > 1:
+
+            s2 = Snom * Snom
+
+            Qmax2 = Qmax if Qmax < Snom else Snom
+            Qmin2 = Qmin if Qmin > -Snom else -Snom
+
+            # Compute the intersections of the Qlimits with the natural curve
+            p0_max = np.sqrt(s2 - Qmax2 * Qmax2)
+            p0_min = np.sqrt(s2 - Qmin2 * Qmin2)
+            p0 = min(p0_max, p0_min)  # pick the lower limit as the starting point for sampling
+
+            # generate evenly spaced active power points from 0 to Snom
+            self._q_points[1:, 0] = np.linspace(p0, Snom, n - 1)
+
+            # enter the base points
+            self._q_points[0, 0] = 0
+            self._q_points[0, 1] = Qmin2
+            self._q_points[0, 2] = Qmax2
+
+            for i in range(1, n):
+                p2 = self._q_points[i, 0] * self._q_points[i, 0]  # P^2
+                q = np.sqrt(s2 - p2)  # point that naturally matches Q = sqrt(S^2 - P^2)
+
+                # assign the natural point if it does not violates the limits imposes, else set the limit
+                qmin = -q if -q > Qmin2 else Qmin2
+                qmax = q if q < Qmax2 else Qmax2
+
+                # Enforce that Qmax > Qmin
+                if qmax < qmin:
+                    qmax = qmin
+                if qmin > qmax:
+                    qmin = qmax
+
+                # Assign the points
+                self._q_points[i, 1] = qmin
+                self._q_points[i, 2] = qmax
+
+        else:
+            self._q_points[0, 0] = 0
+            self._q_points[0, 1] = Qmin
+            self._q_points[0, 2] = Qmax
+
+    def get_q_limits(self, p: float) -> Tuple[float, float]:
+        """
+        Get the reactive power limits
+        :param p: active power value (or array)
+        :return: Qmin (float), Qmax (float)
+        """
+        if self._q_points.shape[0] > 1:
+            all_p = self._q_points[:, 0]
+            all_qmin = self._q_points[:, 1]
+            all_qmax = self._q_points[:, 2]
+
+            qmin = np.interp(p, all_p, all_qmin)
+            qmax = np.interp(p, all_p, all_qmax)
+
+            return qmin, qmax
+        else:
+            return self._q_points[0, 1], self._q_points[0, 2]
+
+    def get_qmax(self, p: float) -> float:
+        """
+        Get Qmax
+        :param p: active power value in MW
+        :return: Qmax in MVAr
+        """
+        if self._q_points.shape[0] > 1:
+            return np.interp(p, self._q_points[:, 0], self._q_points[:, 2])
+        else:
+            return self._q_points[0, 2]
+
+    def get_qmin(self, p: float) -> float:
+        """
+        Get Qmin
+        :param p: active power value in MW
+        :return: Qmin in MVAr
+        """
+        if self._q_points.shape[0] > 1:
+            return np.interp(p, self._q_points[:, 0], self._q_points[:, 1])
+        else:
+            return self._q_points[0, 1]
+
+    def __str__(self):
+        """
+        Get string representation of the curve
+        :return: json string of list of lists: "[[P1, Qmin1, Qmax1], [P2, Qmin2, Qmax2], ...]"
+        """
+        return self.str()
+
+    def str(self) -> str:
+        """
+        Get string representation of the curve
+        :return: json string of list of lists: "[[P1, Qmin1, Qmax1], [P2, Qmin2, Qmax2], ...]"
+        """
+        return json.dumps(self._q_points.tolist())
+
+    def parse(self, val: str):
+        """
+        Parse json curve data
+        :param val: string value: "[[P1, Qmin1, Qmax1], [P2, Qmin2, Qmax2], ...]"
+        """
+        data = json.loads(val)
+        n = len(data)
+        self._q_points = np.zeros((n, 3))
+        for i, row in enumerate(data):
+            self._q_points[i, 0] = row[0]
+            self._q_points[i, 1] = row[1]
+            self._q_points[i, 2] = row[2]
+
+    def get_Qmin(self):
+
+        return self._q_points[:, 1].min()
+
+    def get_Qmax(self):
+
+        return self._q_points[:, 2].max()
+
+    def get_Pmin(self):
+
+        return self._q_points[:, 0].min()
+
+    def get_Pmax(self):
+
+        return self._q_points[:, 0].max()
+
+    def get_Snom(self):
+
+        qmin = self._q_points[:, 1].min()
+        qmax = self._q_points[:, 2].max()
+
+        qfinal = max(abs(qmin), abs(qmax))
+        pmax = self._q_points[:, 0].max()
+
+        return np.sqrt(pmax * pmax + qfinal * qfinal)
+
+    def plot(self, ax: plt.axis):
+        """
+
+        :param ax:
+        :return:
+        """
+        x = self._q_points[:, 0]
+        y1 = self._q_points[:, 1]
+        y2 = self._q_points[:, 2]
+        ax.plot(x, y1,
+                color='red',
+                marker='o',
+                linestyle='solid',
+                linewidth=2,
+                markersize=4)
+        ax.plot(x, y2,
+                color='red',
+                marker='o',
+                linestyle='solid',
+                linewidth=2,
+                markersize=4)
+        ax.set_xlabel("Q (MVAr)")
+        ax.set_ylabel("P (MW)")

{GridCalEngine-5.0.0a18 → GridCalEngine-5.0.0a19}/GridCalEngine/Core/Devices/editable_device.py

@@ -277,15 +277,17 @@ class EditableDevice:
         data = list()
         for name, properties in self.editable_headers.items():
             obj = getattr(self, name)
-            if properties.tpe not in [str, float, int, bool]:
+            if properties.tpe in [str, float, int, bool]:
+                data.append(obj)
+            elif properties.tpe == DeviceType.GeneratorQCurve:
+                data.append(obj.str())
+            else:
                 # if the object is not of a primary type, get the idtag instead
                 if hasattr(obj, 'idtag'):
                     data.append(obj.idtag)
                 else:
                     # some data types might not have the idtag, ten just use the str method
                     data.append(str(obj))
-            else:
-                data.append(obj)
         return data
 
     def get_headers(self) -> List[AnyStr]:
@@ -421,7 +423,10 @@ class EditableDevice:
         """
         tpe = type(self)
 
-        new_obj = tpe()
+        new_obj = tpe(name=self.name,
+                      idtag=self.idtag,
+                      device_type=self.device_type,
+                      code=self.code)
 
         for prop_name, value in self.__dict__.items():
             setattr(new_obj, prop_name, value)