GridCalEngine 5.0.10__tar.gz → 5.0.11__tar.gz

{GridCalEngine-5.0.10 → GridCalEngine-5.0.11}/GridCalEngine/Core/Compilers/circuit_to_bentayga.py

@@ -568,6 +568,11 @@ def get_snapshots_from_bentayga(circuit: MultiCircuit):
                                 ngen=0,
                                 nbatt=0,
                                 nshunt=0,
+                                nfluidnode=0,
+                                nfluidturbine=0,
+                                nfluidpump=0,
+                                nfluidp2x=0,
+                                nfluidpath=0,
                                 sbase=0.0)
 
         data.Vbus_ = btg_data.Vbus.reshape(-1, 1)

{GridCalEngine-5.0.10 → GridCalEngine-5.0.11}/GridCalEngine/Core/Compilers/circuit_to_data.py

@@ -15,7 +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 __future__ import annotations
-from typing import Dict, Union, TYPE_CHECKING
+from typing import Dict, Union, TYPE_CHECKING, Tuple
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Core.Devices.Substation.bus import Bus
 from GridCalEngine.Core.Devices.Aggregation.area import Area
@@ -112,6 +112,9 @@ def get_load_data(circuit: MultiCircuit,
         data.names[ii] = elm.name
         data.idtag[ii] = elm.idtag
 
+        data.mttf[ii] = elm.mttf
+        data.mttr[ii] = elm.mttr
+
         if time_series:
             if opf_results is not None:
                 data.S[ii] = elm.P_prof[t_idx] + 1j * elm.Q_prof[t_idx] - opf_results.load_shedding[t_idx, ii]
@@ -245,6 +248,9 @@ def get_shunt_data(circuit: MultiCircuit,
         data.names[k] = elm.name
         data.idtag[k] = elm.idtag
 
+        data.mttf[k] = elm.mttf
+        data.mttr[k] = elm.mttr
+
         data.controlled[k] = elm.is_controlled
         data.b_min[k] = elm.Bmin
         data.b_max[k] = elm.Bmax
@@ -275,7 +281,7 @@ def get_generator_data(circuit: MultiCircuit,
                        opf_results: Union[OptimalPowerFlowResults, None] = None,
                        t_idx=-1,
                        time_series=False,
-                       use_stored_guess=False) -> ds.GeneratorData:
+                       use_stored_guess=False) -> Tuple[ds.GeneratorData, Dict[str, int]]:
     """
 
     :param circuit:
@@ -304,6 +310,9 @@ def get_generator_data(circuit: MultiCircuit,
         data.names[k] = elm.name
         data.idtag[k] = elm.idtag
 
+        data.mttf[k] = elm.mttf
+        data.mttr[k] = elm.mttr
+
         data.controllable[k] = elm.is_controlled
         data.installed_p[k] = elm.Snom
 
@@ -383,7 +392,7 @@ def get_generator_data(circuit: MultiCircuit,
 
         data.C_bus_elm[i, k] = 1
 
-    return data
+    return data, gen_index_dict
 
 
 def get_battery_data(circuit: MultiCircuit,
@@ -420,6 +429,9 @@ def get_battery_data(circuit: MultiCircuit,
         data.names[k] = elm.name
         data.idtag[k] = elm.idtag
 
+        data.mttf[k] = elm.mttf
+        data.mttr[k] = elm.mttr
+
         data.controllable[k] = elm.is_controlled
         data.installed_p[k] = elm.Snom
 
@@ -510,28 +522,28 @@ def get_battery_data(circuit: MultiCircuit,
 
 
 def get_branch_data(circuit: MultiCircuit,
-                    bus_dict,
-                    Vbus,
-                    apply_temperature,
+                    bus_dict: Dict[Bus, int],
+                    Vbus: CxVec,
+                    apply_temperature: bool,
                     branch_tolerance_mode: BranchImpedanceMode,
-                    t_idx=-1,
-                    time_series=False,
+                    t_idx: int = -1,
+                    time_series: bool = False,
                     opf_results: Union[OptimalPowerFlowResults, None] = None,
-                    use_stored_guess=False,
-                    logger: Logger = Logger()):
+                    use_stored_guess: bool = False,
+                    logger: Logger = Logger()) -> ds.BranchData:
     """
-
-    :param circuit:
-    :param bus_dict:
+    Compile BranchData for a time step or the snapshot
+    :param circuit: MultiCircuit
+    :param bus_dict: Dictionary of buses to compute the indices
     :param Vbus: Array of bus voltages to be modified
-    :param apply_temperature:
-    :param branch_tolerance_mode:
-    :param t_idx:
-    :param time_series:
-    :param opf_results:
-    :param use_stored_guess:
-    :param logger:
-    :return:
+    :param apply_temperature: apply the temperature correction?
+    :param branch_tolerance_mode: BranchImpedanceMode
+    :param t_idx: time index (-1 is useless)
+    :param time_series: compile time series? else the sanpshot is compiled
+    :param opf_results: OptimalPowerFlowResults
+    :param use_stored_guess: use the stored voltage ?
+    :param logger: Logger
+    :return: BranchData
     """
 
     data = ds.BranchData(nelm=circuit.get_branch_number_wo_hvdc(),
@@ -545,6 +557,9 @@ def get_branch_data(circuit: MultiCircuit,
         data.names[i] = elm.name
         data.idtag[i] = elm.idtag
 
+        data.mttf[i] = elm.mttf
+        data.mttr[i] = elm.mttr
+
         if time_series:
             data.active[i] = elm.active_prof[t_idx]
             data.rates[i] = elm.rate_prof[t_idx]
@@ -604,6 +619,10 @@ def get_branch_data(circuit: MultiCircuit,
 
         data.names[ii] = elm.name
         data.idtag[ii] = elm.idtag
+
+        data.mttf[ii] = elm.mttf
+        data.mttr[ii] = elm.mttr
+
         data.dc[ii] = 1
 
         if time_series:
@@ -649,6 +668,9 @@ def get_branch_data(circuit: MultiCircuit,
         data.names[ii] = elm.name
         data.idtag[ii] = elm.idtag
 
+        data.mttf[ii] = elm.mttf
+        data.mttr[ii] = elm.mttr
+
         if time_series:
             data.active[ii] = elm.active_prof[t_idx]
             data.rates[ii] = elm.rate_prof[t_idx]
@@ -730,6 +752,9 @@ def get_branch_data(circuit: MultiCircuit,
             data.names[ii] = elm.name
             data.idtag[ii] = elm.idtag
 
+            data.mttf[ii] = elm.mttf
+            data.mttr[ii] = elm.mttr
+
             if time_series:
                 data.active[ii] = elm.active_prof[t_idx]
                 data.rates[ii] = elm.rate_prof[t_idx]
@@ -813,6 +838,9 @@ def get_branch_data(circuit: MultiCircuit,
         data.names[ii] = elm.name
         data.idtag[ii] = elm.idtag
 
+        data.mttf[ii] = elm.mttf
+        data.mttr[ii] = elm.mttr
+
         if time_series:
             data.active[ii] = elm.active_prof[t_idx]
             data.rates[ii] = elm.rate_prof[t_idx]
@@ -912,6 +940,9 @@ def get_branch_data(circuit: MultiCircuit,
         data.names[ii] = elm.name
         data.idtag[ii] = elm.idtag
 
+        data.mttf[ii] = elm.mttf
+        data.mttr[ii] = elm.mttr
+
         if time_series:
             data.active[ii] = elm.active_prof[t_idx]
             data.rates[ii] = elm.rate_prof[t_idx]
@@ -1041,3 +1072,152 @@ def get_hvdc_data(circuit: MultiCircuit,
         data.C_hvdc_bus_t[i, t] = 1
 
     return data
+
+
+def get_fluid_node_data(circuit: MultiCircuit,
+                        t_idx=-1,
+                        time_series=False) -> Tuple[ds.FluidNodeData, Dict[str, int]]:
+    """
+
+    :param circuit:
+    :param time_series:
+    :param t_idx:
+    :return:
+    """
+    devices = circuit.get_fluid_nodes()
+    plant_dict: Dict[str, int] = dict()
+
+    data = ds.FluidNodeData(nelm=len(devices))
+
+    for k, elm in enumerate(devices):
+        plant_dict[elm.idtag] = k
+
+        data.names[k] = elm.name
+        data.idtag[k] = elm.idtag
+
+        # Convert input data in hm3 to m3
+        data.min_level[k] = 1e6 * elm.min_level
+        data.max_level[k] = 1e6 * elm.max_level
+        data.initial_level[k] = 1e6 * elm.initial_level
+
+        if time_series:
+            data.inflow[k] = elm.inflow_prof[t_idx]
+        else:
+            data.inflow[k] = elm.inflow
+
+    return data, plant_dict
+
+
+def get_fluid_turbine_data(circuit: MultiCircuit,
+                           plant_dict: Dict[str, int],
+                           gen_dict: Dict[str, int],
+                           t_idx=-1) -> ds.FluidTurbineData:
+    """
+
+    :param circuit:
+    :param plant_dict:
+    :param gen_dict:
+    :param t_idx:
+    :return:
+    """
+    devices = circuit.get_fluid_turbines()
+
+    data = ds.FluidTurbineData(nelm=len(devices))
+
+    for k, elm in enumerate(devices):
+        data.plant_idx[k] = plant_dict[elm.plant.idtag]
+        data.generator_idx[k] = gen_dict[elm.generator.idtag]
+
+        data.names[k] = elm.name
+        data.idtag[k] = elm.idtag
+
+        data.efficiency[k] = elm.efficiency
+        data.max_flow_rate[k] = elm.max_flow_rate
+
+    return data
+
+
+def get_fluid_pump_data(circuit: MultiCircuit,
+                        plant_dict: Dict[str, int],
+                        gen_dict: Dict[str, int],
+                        t_idx=-1) -> ds.FluidPumpData:
+    """
+
+    :param circuit:
+    :param plant_dict:
+    :param gen_dict:
+    :param t_idx:
+    :return:
+    """
+    devices = circuit.get_fluid_pumps()
+
+    data = ds.FluidPumpData(nelm=len(devices))
+
+    for k, elm in enumerate(devices):
+        data.plant_idx[k] = plant_dict[elm.plant.idtag]
+        data.generator_idx[k] = gen_dict[elm.generator.idtag]
+
+        data.names[k] = elm.name
+        data.idtag[k] = elm.idtag
+
+        data.efficiency[k] = elm.efficiency
+        data.max_flow_rate[k] = elm.max_flow_rate
+
+    return data
+
+
+def get_fluid_p2x_data(circuit: MultiCircuit,
+                       plant_dict: Dict[str, int],
+                       gen_dict: Dict[str, int],
+                       t_idx=-1) -> ds.FluidP2XData:
+    """
+
+    :param circuit:
+    :param plant_dict:
+    :param gen_dict:
+    :param t_idx:
+    :return:
+    """
+    devices = circuit.get_fluid_p2xs()
+
+    data = ds.FluidP2XData(nelm=len(devices))
+
+    for k, elm in enumerate(devices):
+        data.plant_idx[k] = plant_dict[elm.plant.idtag]
+        data.generator_idx[k] = gen_dict[elm.generator.idtag]
+
+        data.names[k] = elm.name
+        data.idtag[k] = elm.idtag
+
+        data.efficiency[k] = elm.efficiency
+        data.max_flow_rate[k] = elm.max_flow_rate
+
+    return data
+
+
+def get_fluid_path_data(circuit: MultiCircuit,
+                        plant_dict: Dict[str, int],
+                        t_idx=-1) -> ds.FluidPathData:
+    """
+
+    :param circuit:
+    :param plant_dict:
+    :param t_idx:
+    :return:
+    """
+    devices = circuit.get_fluid_paths()
+
+    data = ds.FluidPathData(nelm=len(devices))
+
+    for k, elm in enumerate(devices):
+        data.names[k] = elm.name
+        data.idtag[k] = elm.idtag
+
+        # pass idx, check
+        data.source_idx[k] = plant_dict[elm.source.idtag]
+        data.target_idx[k] = plant_dict[elm.target.idtag]
+
+        data.min_flow[k] = elm.min_flow
+        data.max_flow[k] = elm.max_flow
+
+    return data

{GridCalEngine-5.0.10 → GridCalEngine-5.0.11}/GridCalEngine/Core/Compilers/circuit_to_newton_pa.py

@@ -33,11 +33,11 @@ from GridCalEngine.basic_structures import ConvergenceReport
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
-    from GridCalEngine.Simulations.OPF.opf_options import OptimalPowerFlowOptions, ZonalGrouping
+    from GridCalEngine.Simulations.OPF.opf_options import OptimalPowerFlowOptions
     from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
+    from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
 
-
-NEWTON_PA_RECOMMENDED_VERSION = "2.1.13"
+NEWTON_PA_RECOMMENDED_VERSION = "2.1.14"
 NEWTON_PA_VERSION = ''
 NEWTON_PA_AVAILABLE = False
 try:
@@ -47,27 +47,31 @@ try:
 
     # activate
     if not npa.isLicenseActivated():
+
+        # search for the license
         npa_license = os.path.join(get_create_gridcal_folder(), 'newton.lic')
         if os.path.exists(npa_license):
+
+            # license found
             npa.activateLicense(npa_license)
             if npa.isLicenseActivated():
+
+                # license valie
                 NEWTON_PA_AVAILABLE = True
+                NEWTON_PA_VERSION = npa.get_version()
 
-                if npa.get_version() < NEWTON_PA_RECOMMENDED_VERSION:
-                    warnings.warn(f"Recommended version for Newton is {NEWTON_PA_RECOMMENDED_VERSION} "
-                                  f"instead of {npa.get_version()}")
             else:
-                # print('Newton Power Analytics v' + npa.get_version(),
-                #       "installed, tried to activate with {} but the license did not work :/".format(npa_license))
+                # license not valid
                 NEWTON_PA_AVAILABLE = False
         else:
-            # print('Newton Power Analytics v' + npa.get_version(), "installed but not licensed")
+            # license not found
             NEWTON_PA_AVAILABLE = False
     else:
-        # print('Newton Power Analytics v' + npa.get_version())
+        # already activated
         NEWTON_PA_AVAILABLE = True
         NEWTON_PA_VERSION = npa.get_version()
 
+    if NEWTON_PA_AVAILABLE:
         if NEWTON_PA_VERSION < NEWTON_PA_RECOMMENDED_VERSION:
             warnings.warn(f"Recommended version for Newton is {NEWTON_PA_RECOMMENDED_VERSION} "
                           f"instead of {NEWTON_PA_VERSION}")
@@ -75,7 +79,6 @@ try:
 except ImportError as e:
     NEWTON_PA_AVAILABLE = False
     NEWTON_PA_VERSION = ''
-    # print('Newton Power Analytics is not available:', e)
 
 # numpy integer type for Newton's uword
 BINT = np.ulonglong
@@ -989,8 +992,10 @@ def to_newton_pa(circuit: MultiCircuit,
     add_npa_generators(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices, opf_results)
     add_battery_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices, opf_results)
     add_npa_line(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices)
-    add_transformer_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices, override_branch_controls)
-    add_transformer3w_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices, override_branch_controls)
+    add_transformer_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices,
+                         override_branch_controls)
+    add_transformer3w_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices,
+                           override_branch_controls)
     add_vsc_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices)
     add_dc_line_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices)
     add_hvdc_data(circuit, npa_circuit, bus_dict, use_time_series, n_time, time_indices)
@@ -1005,7 +1010,7 @@ class FakeAdmittances:
     Fake admittances class needed to make the translation
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.Ybus = None
         self.Yf = None
         self.Yt = None
@@ -1035,6 +1040,11 @@ def get_snapshots_from_newtonpa(circuit: MultiCircuit, override_branch_controls=
                                 ngen=0,
                                 nbatt=0,
                                 nshunt=0,
+                                nfluidnode=0,
+                                nfluidturbine=0,
+                                nfluidpump=0,
+                                nfluidp2x=0,
+                                nfluidpath=0,
                                 sbase=0,
                                 t_idx=0)
 
@@ -1312,7 +1322,6 @@ def newton_pa_contingencies(circuit: MultiCircuit,
         mode = npa.ContingencyAnalysisMode.Full
 
     # npa.FileHandler().save(npa_circuit, "whatever.newton")
-
     # print('time_indices')
     # print(time_indices)
 
@@ -1554,6 +1563,65 @@ def translate_newton_pa_opf_results(grid: MultiCircuit, res: "npa.NonlinearOpfRe
     return results
 
 
+def translate_contingency_report(newton_report, gridcal_report):
+    """
+    Translate contingency report
+    :param newton_report:
+    :param gridcal_report:
+    :return:
+    """
+    for entry in newton_report.entries:
+        gridcal_report.add(time_index=entry.time_index,
+                           base_name=entry.base_name,
+                           base_uuid=entry.base_uuid,
+                           base_flow=np.abs(entry.base_flow),
+                           base_rating=entry.base_rating,
+                           base_loading=entry.base_loading,
+                           contingency_idx=entry.contingency_idx,
+                           contingency_name=entry.contingency_name,
+                           contingency_uuid=entry.contingency_uuid,
+                           post_contingency_flow=np.abs(entry.post_contingency_flow),
+                           contingency_rating=entry.contingency_rating,
+                           post_contingency_loading=entry.post_contingency_loading)
+
+
+def translate_newton_pa_contingencies(grid: MultiCircuit,
+                                      con_res: "npa.ContingencyAnalysisResults") -> ContingencyAnalysisResults:
+    """
+
+    :param grid:
+    :param con_res:
+    :return:
+    """
+    from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
+
+    # declare the results
+    results = ContingencyAnalysisResults(ncon=len(grid.contingency_groups),
+                                         nbr=grid.get_branch_number_wo_hvdc(),
+                                         nbus=grid.get_bus_number(),
+                                         branch_names=grid.get_branch_names_wo_hvdc(),
+                                         bus_names=grid.get_bus_names(),
+                                         bus_types=grid.get_bus_default_types(),
+                                         con_names=grid.get_contingency_group_names())
+
+    """
+    self.voltage: CxMat = np.ones((ncon, nbus), dtype=complex)
+    self.Sbus: CxMat = np.zeros((ncon, nbus), dtype=complex)
+    self.Sf: CxMat = np.zeros((ncon, nbr), dtype=complex)
+    self.loading: CxMat = np.zeros((ncon, nbr), dtype=complex)
+
+    self.report: ContingencyResultsReport = ContingencyResultsReport()
+    """
+
+    # results.voltage = con_res.contingency_voltages[0]  # these are not translatable
+    # results.Sf = con_res.contingency_flows[0]
+    # results.loading = con_res.contingency_loading[0]
+    translate_contingency_report(newton_report=con_res.report,
+                                 gridcal_report=results.report)
+
+    return results
+
+
 def debug_newton_pa_circuit_at(npa_circuit: "npa.HybridCircuit", t: int = None):
     """
     Debugging function

{GridCalEngine-5.0.10 → GridCalEngine-5.0.11}/GridCalEngine/Core/DataStructures/__init__.py

@@ -21,3 +21,8 @@ from GridCalEngine.Core.DataStructures.generator_data import GeneratorData
 from GridCalEngine.Core.DataStructures.hvdc_data import HvdcData
 from GridCalEngine.Core.DataStructures.load_data import LoadData
 from GridCalEngine.Core.DataStructures.shunt_data import ShuntData
+from GridCalEngine.Core.DataStructures.fluid_node_data import FluidNodeData
+from GridCalEngine.Core.DataStructures.fluid_turbine_data import FluidTurbineData
+from GridCalEngine.Core.DataStructures.fluid_pump_data import FluidPumpData
+from GridCalEngine.Core.DataStructures.fluid_p2x_data import FluidP2XData
+from GridCalEngine.Core.DataStructures.fluid_path_data import FluidPathData

{GridCalEngine-5.0.10 → GridCalEngine-5.0.11}/GridCalEngine/Core/DataStructures/branch_data.py

@@ -66,6 +66,10 @@ class BranchData:
         self.F: IntVec = np.zeros(self.nelm, dtype=int)  # indices of the "from" buses
         self.T: IntVec = np.zeros(self.nelm, dtype=int)  # indices of the "to" buses
 
+        # reliabilty
+        self.mttf: Vec = np.zeros(self.nelm, dtype=float)
+        self.mttr: Vec = np.zeros(self.nelm, dtype=float)
+
         # composite losses curve (a * x^2 + b * x + c)
         self.a: Vec = np.zeros(self.nelm, dtype=float)
         self.b: Vec = np.zeros(self.nelm, dtype=float)
@@ -140,6 +144,9 @@ class BranchData:
         data.names = self.names[elm_idx]
         data.idtag = self.idtag[elm_idx]
 
+        data.mttf = self.mttf[elm_idx]
+        data.mttr = self.mttr[elm_idx]
+
         data.R = self.R[elm_idx]
         data.X = self.X[elm_idx]
         data.G = self.G[elm_idx]
@@ -212,6 +219,9 @@ class BranchData:
         data.names = self.names.copy()
         data.idtag = self.idtag.copy()
 
+        data.mttf = self.mttf.copy()
+        data.mttr = self.mttr.copy()
+
         data.R = self.R.copy()
         data.X = self.X.copy()
         data.G = self.G.copy()

GridCalEngine-5.0.11/GridCalEngine/Core/DataStructures/fluid_node_data.py

@@ -0,0 +1,61 @@
+# 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 numpy as np
+from GridCalEngine.basic_structures import Vec, CxVec, IntVec, StrVec
+
+
+class FluidNodeData:
+    """
+    FluidNodeData
+    """
+
+    def __init__(self, nelm: int):
+        """
+        Fluid node data arrays
+        :param nelm: number of fluid nodes
+        """
+        self.nelm: int = nelm
+
+        self.names: StrVec = np.empty(nelm, dtype=object)
+        self.idtag: StrVec = np.empty(nelm, dtype=object)
+
+        self.min_level = np.zeros(nelm, dtype=float)
+        self.max_level = np.zeros(nelm, dtype=float)
+        self.initial_level = np.zeros(nelm, dtype=float)
+        # self.bus_index = np.empty()  # TODO: check if relevant
+        self.inflow = np.zeros(nelm, dtype=float)
+
+    def copy(self) -> "FluidNodeData":
+        """
+        Get deep copy of this structure
+        :return: new FluidNodeData instance
+        """
+
+        data = FluidNodeData(nelm=self.nelm)
+
+        data.names = self.names.copy()
+        data.idtag = self.idtag.copy()
+
+        data.min_level = self.min_level.copy()
+        data.max_level = self.max_level.copy()
+        data.initial_level = self.initial_level.copy()
+
+        data.inflow = self.inflow.copy()
+
+        return data
+
+

GridCalEngine-5.0.11/GridCalEngine/Core/DataStructures/fluid_p2x_data.py

@@ -0,0 +1,33 @@
+# 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 GridCalEngine.Core.DataStructures.fluid_turbine_data import FluidTurbineData
+
+
+class FluidP2XData(FluidTurbineData):
+    """
+    FluidP2XData
+    """
+
+    def __init__(self, nelm: int):
+        """
+        Fluid P2X data arrays
+        :param nelm: number of fluid p2xs
+        """
+
+        FluidTurbineData.__init__(self,
+                                  nelm=nelm)
+