From 9c776d100018e293b1ee45830cd07d9dcad43d96 Mon Sep 17 00:00:00 2001 From: raphamac Date: Wed, 13 Mar 2024 21:54:41 -0300 Subject: [PATCH 01/11] teste --- examples/no_study.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/no_study.py b/examples/no_study.py index c88e5ad..7395238 100644 --- a/examples/no_study.py +++ b/examples/no_study.py @@ -21,5 +21,5 @@ dss_tools.model.add_line_in_vsource(add_meter=True) dss.text("solve") dss_tools.dss_view.voltage_profile() - +#teste print("here") From 5c8ea229df1907f5a7fecfb48fb2d6e6b191dec3 Mon Sep 17 00:00:00 2001 From: raphamac Date: Wed, 13 Mar 2024 22:40:15 -0300 Subject: [PATCH 02/11] =?UTF-8?q?Inclus=C3=A3o=20dos=20VTCD=20Study=20e=20?= =?UTF-8?q?demais=20c=C3=B3digos=20de=20VTCD=20que=20havia=20feito.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/py_dss_tools/api/Creation.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/py_dss_tools/api/Creation.py b/src/py_dss_tools/api/Creation.py index 23837cf..4ab61ef 100644 --- a/src/py_dss_tools/api/Creation.py +++ b/src/py_dss_tools/api/Creation.py @@ -9,6 +9,7 @@ from py_dss_tools.studies.StudyPowerFlow import StudyPowerFlow from py_dss_tools.studies.StudyTemporal import StudyTemporal from py_dss_tools.studies.StudyFault import StudyFault +from py_dss_tools.studies.StudyVTCD import StudyVTCD from typing import Optional @@ -56,6 +57,14 @@ def fault_study( sc = StudyFault(_name=name, _dss_file=dss_file, _frequency_base=frequency_base, _dll=dll) return sc + @staticmethod + def vtcd_study( + name: str, + dss_file: str, + frequency_base: [int, float] = 60, + dll: Optional[str] = None) -> StudyVTCD: + sc = StudyVTCD(_name=name, _dss_file=dss_file, _frequency_base=frequency_base, _dll=dll) + return sc # def update_circuit_df(sc: Scenario): # if sc.circuit.created: From 1f36e031f3f0bcbbb9d2eab5e10b040afe1db365 Mon Sep 17 00:00:00 2001 From: raphamac Date: Wed, 13 Mar 2024 22:57:10 -0300 Subject: [PATCH 03/11] After the fork I have included my VTCD study files. --- examples/vtcd_study_exemple.py | 31 ++++ src/py_dss_tools/results/BckupFuncoes.py | 171 ++++++++++++++++++++++ src/py_dss_tools/results/VTCDresults.py | 59 ++++++++ src/py_dss_tools/results/VtcdSagSwell.py | 49 +++++++ src/py_dss_tools/studies/StudyVTCD.py | 32 ++++ src/py_dss_tools/view/VTCDbusesNameTag.py | 22 +++ src/py_dss_tools/view/ViewVTCDstudy.py | 43 ++++++ 7 files changed, 407 insertions(+) create mode 100644 examples/vtcd_study_exemple.py create mode 100644 src/py_dss_tools/results/BckupFuncoes.py create mode 100644 src/py_dss_tools/results/VTCDresults.py create mode 100644 src/py_dss_tools/results/VtcdSagSwell.py create mode 100644 src/py_dss_tools/studies/StudyVTCD.py create mode 100644 src/py_dss_tools/view/VTCDbusesNameTag.py create mode 100644 src/py_dss_tools/view/ViewVTCDstudy.py diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py new file mode 100644 index 0000000..cbc1347 --- /dev/null +++ b/examples/vtcd_study_exemple.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : vtcd_study_exemple.py +# @Software: PyCharm + + +import os +import pathlib +import py_dss_tools + +script_path = os.path.dirname(os.path.abspath(__file__)) + +dss_file = pathlib.Path(script_path).joinpath("feeders", "123Bus", "IEEE123Master.dss") + +study = py_dss_tools.CreateStudy.vtcd_study(name="VTCD Case 1", dss_file=str(dss_file)) +study.dss.text("New EnergyMeter.Feeder Line.L115 1") +study.dss.text(f"Buscoords Buscoords.dat") +study.dss.text("batchedit regcontrol..* enabled=No") +study.dss.text("batchedit load..* enabled=No") + +# study.results.sag_swell_1ph_pu("95","57") #Quado executo mais de uma vez ainda fica o elemento de curto anterior, não sei apagar ainda. +# study.results.sag3ph_pu("95, 57") #Quado executo mais de uma vez ainda fica o elemento de curto anterior, não sei apagar ainda. +# study.results.sag_map_3ph_buses_3ph_sc("95") #Quado executo mais de uma vez ainda fica o elemento de curto anterior, não sei apagar ainda. + +# study.results.sag_swell_maps_1ph_buses_3ph_sc("95") +# study.results.bus_vulnerability_sag_map_sc3ph(str(dss_file),"52") # fiz automático mas gostaria de digitar somente a barra. + +study.results.sag_3phsc_df_pu("95") + +print("here") diff --git a/src/py_dss_tools/results/BckupFuncoes.py b/src/py_dss_tools/results/BckupFuncoes.py new file mode 100644 index 0000000..f7e2e11 --- /dev/null +++ b/src/py_dss_tools/results/BckupFuncoes.py @@ -0,0 +1,171 @@ +from py_dss_interface import DSS +import time +from py_dss_tools.dss_utils import DSSUtils +import pathlib + + +class VTCDresults: + + def __init__(self, dss: DSS): + self._dss = dss + + # Criar uma função nova aqui que aplica o curto em uma barra escolhida e chama a função que o Paulo criou no + # ResultsUtila que é a circuit_vmag_vang_dfs, assim terei um data frame com as tensões em todas as barras. + + + def sag_3phsc_df_pu(self, bus_fault): + self._bus_fault = bus_fault + self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") + self._dss.text("solve") + vmags_df, vangs_df = DSSUtils(self._dss).get_circuit_vmag_vang_dfs() + return vmags_df, vangs_df + + def sag3ph_pu(self, bus_fault, bus_sag): + self._bus_fault = bus_fault + self._bus_sag = bus_sag + self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") + self._dss.text("solve") + self._dss.circuit.set_active_bus(self._bus_sag) + # num_nodes = self._dss.bus.num_nodes #para barra com vários nós. + # nodes = self._dss.bus.nodes + # vmags = self._dss.bus.vmag_angle_pu[: 2 * num_nodes: 2] + # vangs = self._dss.bus.vmag_angle_pu[1: 2 * num_nodes: 2] + return round(min(self._dss.bus.vmag_angle_pu[0:6:2]), 2) + + def sag_swell_1ph_pu(self, bus_fault, bus_sag_swel): + self._bus_fault = bus_fault + self._bus_sag_swell = bus_sag_swel + self._dss.text(f"new fault.1_ph_{self._bus_fault} phases=1 bus1={self._bus_fault}.1 bus2={self._bus_fault}.0") + self._dss.text("solve") + self._dss.circuit.set_active_bus(self._bus_sag_swell) + return round(min(self._dss.bus.vmag_angle_pu[0:6:2]), 2), round(max(self._dss.bus.vmag_angle_pu[0:6:2]), 2) + + def sag_map_3ph_buses_3ph_sc(self, bus_fault, v_1=0.1, v_2=0.5, v_3=0.95): + self._bus_fault = bus_fault + self._v_1 = v_1 + self._v_2 = v_2 + self._v_3 = v_3 + self._dss.text(f"new fault.3_pf_{self._bus_fault} phases=3 bus1={self._bus_fault}") + self._dss.text("solve") + + bus_color_dict = dict() + for bus in self._dss.circuit.buses_names: + self._dss.circuit.set_active_bus(bus) + if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas + v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) + + if v_min < v_1: + bus_color_dict[bus] = "black" + elif v_min < v_2: + bus_color_dict[bus] = "red" + elif v_min < v_3: + bus_color_dict[bus] = "yellow" + else: + bus_color_dict[bus] = "green" + + for bus_name, color in bus_color_dict.items(): + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + def sag_swell_maps_1ph_buses_3ph_sc(self, bus_fault, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vswell_1=1.05, + vswell_2=1.06, vswell_3=1.1): + self._bus_fault = bus_fault + self._vsag_1 = vsag_1 + self._vsag_2 = vsag_2 + self._vsag_3 = vsag_3 + self._vswell_1 = vswell_1 + self._vswell_2 = vswell_2 + self._vswell_3 = vswell_3 + self._dss.text(f"new fault.1_ph_{self._bus_fault} phases=1 bus1={self._bus_fault}.1 bus2={self._bus_fault}.0") + self._dss.text("solve") + + bus_color_dict_sag = dict() + for bus in self._dss.circuit.buses_names: + self._dss.circuit.set_active_bus(bus) + if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas + v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) + + if v_min < vsag_1: + bus_color_dict_sag[bus] = "black" + elif v_min < vsag_2: + bus_color_dict_sag[bus] = "red" + elif v_min < vsag_3: + bus_color_dict_sag[bus] = "yellow" + else: + bus_color_dict_sag[bus] = "green" + + for bus_name, color in bus_color_dict_sag.items(): + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + + self._dss.text("plot circuit Power max=2000 y y C1=$00FF0000") + + # Tempo em segundos para interromper a execução + tempo_de_parada = 1 # Alterei para a quantidade desejada de segundos + time.sleep(tempo_de_parada) + + bus_color_dict_swell = dict() + for bus in self._dss.circuit.buses_names: + self._dss.circuit.set_active_bus(bus) + if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas + v_max = max(self._dss.bus.vmag_angle_pu[0:6:2]) + + if v_max <= vswell_1: + bus_color_dict_swell[bus] = "green" + elif v_max <= vswell_2: + bus_color_dict_swell[bus] = "yellow" + elif v_max <= vswell_3: + bus_color_dict_swell[bus] = "red" + else: + bus_color_dict_swell[bus] = "black" + for bus_name, color in bus_color_dict_swell.items(): + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + # def compile_dss(self, dss_file: str): + # self._dss.text("ClearAll") + # self._dss.text("Compile " + "[" + dss_file + "]") + + def bus_vulnerability_sag_map_sc3ph(self, dss_file: str, bus_analyzed, v_1=0.1, v_2=0.5, v_3=0.95): + self._bus_analyzed = bus_analyzed + self._v_1 = v_1 + self._v_2 = v_2 + self._v_3 = v_3 + + bus_names = list() + for bus in self._dss.circuit.buses_names: + self._dss.circuit.set_active_bus(bus) + if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: + bus_names.append(bus) + + bus_color_dict = dict() + for bus in bus_names: + # self._dss.text("Compile C:/RaphaelMaccari/GitHub/py-dss-tools/examples/feeders/123Bus/IEEE123Master.dss") + self._dss.text(f"Compile [{dss_file}]") + # pensar como fazer o compile com o link automático do aquivo. + + self._dss.text("batchedit regcontrol..* enabled=No") + self._dss.text("batchedit load..* enabled=No") + self._dss.text(f"Buscoords Buscoords.dat") + self._dss.text(f"new fault.3_ph phases=3 bus1={bus}") + self._dss.text("solve") + + self._dss.circuit.set_active_bus(self._bus_analyzed) + + v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) + + if v_min < v_1: + bus_color_dict[bus] = "black" + elif v_min < v_2: + bus_color_dict[bus] = "red" + elif v_min < v_3: + bus_color_dict[bus] = "yellow" + else: + print(v_min) + bus_color_dict[bus] = "green" + + for bus_name, color in bus_color_dict.items(): + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + + self._dss.text("plot circuit Power max=2000 y n C1=$00FF0000") + diff --git a/src/py_dss_tools/results/VTCDresults.py b/src/py_dss_tools/results/VTCDresults.py new file mode 100644 index 0000000..f57ffda --- /dev/null +++ b/src/py_dss_tools/results/VTCDresults.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccair +# @Email : raphaelmaccari@gmail.com +# @File : VTCDresults.py +# @Software: PyCharm + +from py_dss_interface import DSS +from py_dss_tools.dss_tools import DSSTools +import time +import pathlib + + + +class VTCDresults: + + def __init__(self, dss: DSS): + self._dss = dss + + def sag_3phsc_df_pu(self, bus_fault): + self._bus_fault = bus_fault + self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") + self._dss.text("solve") + vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + vmags_df['vmin'] = vmags_df.iloc[:, :-1].min(axis=1) + vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1) + print(vmags_df) + + + return vmags_df, vangs_df + + # estou trabalhando nesse código aqui para facilitar o acesso via o study example, mas no fim passarei ele para VtcdSagSwell. + + + + + + + + + + + + + + + # num_nodes = self._dss.bus.num_nodes #para barra com vários nós. + # nodes = self._dss.bus.nodes + # vmags = self._dss.bus.vmag_angle_pu[: 2 * num_nodes: 2] + # vangs = self._dss.bus.vmag_angle_pu[1: 2 * num_nodes: 2] + # return round(min(self._dss.bus.vmag_angle_pu[0:6:2]), 2) + + #disponibilizar aqui o + + + #Criar uma função nova aqui que aplica o curto em uma barra escolhida e chama a função que o Paulo criou no + #ResultsUtila que é a circuit_vmag_vang_dfs, assim terei um data frame com as tensões em todas as barras. + + + diff --git a/src/py_dss_tools/results/VtcdSagSwell.py b/src/py_dss_tools/results/VtcdSagSwell.py new file mode 100644 index 0000000..abc7ca2 --- /dev/null +++ b/src/py_dss_tools/results/VtcdSagSwell.py @@ -0,0 +1,49 @@ +from py_dss_interface import DSS +import time +from py_dss_tools.dss_utils import DSSUtils +import pathlib + + +class VtcdSagSwell: + + def __init__(self, dss: DSS): + self._dss = dss +def sag_df_3ph_sc(self, bus_fault, v_1=0.1, v_2=0.5, v_3=0.95): + self._bus_fault = bus_fault + self._v_1 = v_1 + self._v_2 = v_2 + self._v_3 = v_3 + self._dss.text(f"new fault.3_pf_{self._bus_fault} phases=3 bus1={self._bus_fault}") + self._dss.text("solve") +#estou trabalhando nesse código no VTCDresults, para facilitar, mas depois passarei tudo pra cá + vmags_df, vangs_df = DSSUtils(self._dss).results.circuit_vmag_vang_dfs() + + + + return vmags_df + + + + + + # bus_color_dict = dict() + # for bus in self._dss.circuit.buses_names: + # self._dss.circuit.set_active_bus(bus) + # if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas + # v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) + # + # if v_min < v_1: + # bus_color_dict[bus] = "black" + # elif v_min < v_2: + # bus_color_dict[bus] = "red" + # elif v_min < v_3: + # bus_color_dict[bus] = "yellow" + # else: + # bus_color_dict[bus] = "green" + # + # for bus_name, color in bus_color_dict.items(): + # self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + # + # self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + diff --git a/src/py_dss_tools/studies/StudyVTCD.py b/src/py_dss_tools/studies/StudyVTCD.py new file mode 100644 index 0000000..ca852bc --- /dev/null +++ b/src/py_dss_tools/studies/StudyVTCD.py @@ -0,0 +1,32 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : StudyVTCD.py +# @Software: PyCharm + +from py_dss_tools.studies.StudyBase import StudyBase +from py_dss_tools.results.VTCDresults import VTCDresults +from py_dss_tools.view.ViewVTCDstudy import ViewVTCDresults +from dataclasses import dataclass + +@dataclass(kw_only=True) +class StudyVTCD(StudyBase): + + def __post_init__(self): + super().__post_init__() + self._results = VTCDresults(self._dss) # Object created by composition + self._view = ViewVTCDresults(self._dss, self._results) # não sei o motivo, mas é necessário haver o self._results + # self._view = ViewFaultResults(self._dss, self._results) + # self._settings = StudyTemporalSettings(_dss=self.dss) + @property + def results(self): + return self._results + + @property + def view(self): + return self._view + +#run area vulnerabilit +#run outra coisa?????? + +#incluir um run aqui, recebe bus name aqui. diff --git a/src/py_dss_tools/view/VTCDbusesNameTag.py b/src/py_dss_tools/view/VTCDbusesNameTag.py new file mode 100644 index 0000000..ff4cc25 --- /dev/null +++ b/src/py_dss_tools/view/VTCDbusesNameTag.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : VTCDbusesNameTag.py +# @Software: PyCharm + +from py_dss_interface import DSS +from py_dss_tools.results.VTCDresults import VTCDresults + + +class VTCDbusesNameTag: + + def __init__(self, dss: DSS, results: VTCDresults): + self._results = results + self._dss = dss + + + def plot_circuit_buses_name(self): + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + + diff --git a/src/py_dss_tools/view/ViewVTCDstudy.py b/src/py_dss_tools/view/ViewVTCDstudy.py new file mode 100644 index 0000000..3ac14b4 --- /dev/null +++ b/src/py_dss_tools/view/ViewVTCDstudy.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : ViewVTCDstudy.py +# @Software: PyCharm + +from py_dss_tools.view.VTCDbusesNameTag import VTCDbusesNameTag +from py_dss_interface import DSS +from py_dss_tools.results.VTCDresults import VTCDresults + + +class ViewVTCDresults(VTCDbusesNameTag): + + def __init__(self, dss: DSS, results: VTCDresults): + VTCDbusesNameTag.__init__(self, dss, results) + + + # self._dss = dss #estava aqui, mas está tomando conta dentro da classe VTCbusesNameTag + # self._results = results #estava aqui, mas está tomando conta dentro da classe VTCbusesNameTag + + + # def plot_circuit_buses_name_tag(self): # passei essa função para a classe VTCbusesNameTag, pois neste aquivo + # herdarei cada arquivo de funcionalidade que for criado. + # self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + + + + + + + # PlotCircuitBusesNameTag.__init__(self, dss, results) + + +# from py_dss_tools.results.FaultResults import FaultResults +# from py_dss_tools.view.ShortCircuitImpedances import ShortCircuitImpedances +# from py_dss_interface import DSS +# +# +# class ViewFaultResults(ShortCircuitImpedances): +# +# def __init__(self, dss: DSS, results: FaultResults): +# ShortCircuitImpedances.__init__(self, dss, results) From 4a01660736ebded8128c7f7f6bafdd66ae3a1fb9 Mon Sep 17 00:00:00 2001 From: raphamac Date: Thu, 14 Mar 2024 22:59:15 -0300 Subject: [PATCH 04/11] VTCDresults df included. I need to change this code to a specifc class, and import it in VTCDresults class, because I have used it in VTCDresults class to verify and do some tests. VTCD map included, but I need to use it in future VIEW class. --- src/py_dss_tools/results/VTCDresults.py | 36 ++++++++++++++++++++----- 1 file changed, 29 insertions(+), 7 deletions(-) diff --git a/src/py_dss_tools/results/VTCDresults.py b/src/py_dss_tools/results/VTCDresults.py index f57ffda..02edd5c 100644 --- a/src/py_dss_tools/results/VTCDresults.py +++ b/src/py_dss_tools/results/VTCDresults.py @@ -16,17 +16,39 @@ class VTCDresults: def __init__(self, dss: DSS): self._dss = dss - def sag_3phsc_df_pu(self, bus_fault): + def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95): self._bus_fault = bus_fault + self._v_1 = v_1 + self._v_2 = v_2 + self._v_3 = v_3 self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") self._dss.text("solve") vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() - vmags_df['vmin'] = vmags_df.iloc[:, :-1].min(axis=1) - vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1) - print(vmags_df) - - - return vmags_df, vangs_df + vmags_df = vmags_df.iloc[:, :-1] #Descarta a última coluna. + vmags_df['vmin'] = vmags_df.min(axis=1) + + colors = [] + for v_min in vmags_df['vmin']: + if v_min < v_1: + colors.append("black") + elif v_min < v_2: + colors.append("red") + elif v_min < v_3: + colors.append("yellow") + else: + colors.append("green") + + vmags_df['colors'] = colors + + #o codigo abaixo inserir no VIEW + for index, row in vmags_df.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row.iloc[-1] # Obtém o valor da última coluna (color) + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + ###################################33 + + return vmags_df # estou trabalhando nesse código aqui para facilitar o acesso via o study example, mas no fim passarei ele para VtcdSagSwell. From 7c976aa9650a36b5551ecb01d8eabef3d7e209ae Mon Sep 17 00:00:00 2001 From: raphamac Date: Sat, 16 Mar 2024 21:42:54 -0300 Subject: [PATCH 05/11] VCTCsag class and results/VTCDresults working. VTCDsagCircuit not working, but I am trying. --- examples/vtcd_study_exemple.py | 7 --- src/py_dss_tools/results/VTCDSag.py | 46 +++++++++++++++ src/py_dss_tools/results/VTCDresults.py | 72 +---------------------- src/py_dss_tools/results/VtcdSagSwell.py | 49 --------------- src/py_dss_tools/view/VTCDSagCircuit.py | 36 ++++++++++++ src/py_dss_tools/view/VTCDbusesNameTag.py | 22 ------- src/py_dss_tools/view/ViewVTCDstudy.py | 7 ++- 7 files changed, 89 insertions(+), 150 deletions(-) create mode 100644 src/py_dss_tools/results/VTCDSag.py delete mode 100644 src/py_dss_tools/results/VtcdSagSwell.py create mode 100644 src/py_dss_tools/view/VTCDSagCircuit.py delete mode 100644 src/py_dss_tools/view/VTCDbusesNameTag.py diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py index cbc1347..7894372 100644 --- a/examples/vtcd_study_exemple.py +++ b/examples/vtcd_study_exemple.py @@ -19,13 +19,6 @@ study.dss.text("batchedit regcontrol..* enabled=No") study.dss.text("batchedit load..* enabled=No") -# study.results.sag_swell_1ph_pu("95","57") #Quado executo mais de uma vez ainda fica o elemento de curto anterior, não sei apagar ainda. -# study.results.sag3ph_pu("95, 57") #Quado executo mais de uma vez ainda fica o elemento de curto anterior, não sei apagar ainda. -# study.results.sag_map_3ph_buses_3ph_sc("95") #Quado executo mais de uma vez ainda fica o elemento de curto anterior, não sei apagar ainda. - -# study.results.sag_swell_maps_1ph_buses_3ph_sc("95") -# study.results.bus_vulnerability_sag_map_sc3ph(str(dss_file),"52") # fiz automático mas gostaria de digitar somente a barra. - study.results.sag_3phsc_df_pu("95") print("here") diff --git a/src/py_dss_tools/results/VTCDSag.py b/src/py_dss_tools/results/VTCDSag.py new file mode 100644 index 0000000..85416b0 --- /dev/null +++ b/src/py_dss_tools/results/VTCDSag.py @@ -0,0 +1,46 @@ + + + +import pandas as pd +from py_dss_interface import DSS +from py_dss_tools.dss_tools import DSSTools + + +class VTCDSag: + + def __init__(self, dss: DSS): + self._dss = dss + + def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95) -> pd.DataFrame: + self._bus_fault = bus_fault + self._v_1 = v_1 + self._v_2 = v_2 + self._v_3 = v_3 + self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") + self._dss.text("solve") + vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + vmags_df = vmags_df.iloc[:, :-1] #Descarta a última coluna. + vmags_df['vmin'] = vmags_df.min(axis=1) + + colors = [] + for v_min in vmags_df['vmin']: + if v_min < v_1: + colors.append("black") + elif v_min < v_2: + colors.append("red") + elif v_min < v_3: + colors.append("yellow") + else: + colors.append("green") + + vmags_df['colors'] = colors + + # Necessito que o codigo abaixo que utiliza o vmags_df acima seja executado em outro arquivo dentro de uma classe. + # for index, row in vmags_df.iterrows(): + # bus_name = index # Obtém o valor da primeira coluna (bus_name) + # color = row.iloc[-1] # Obtém o valor da última coluna (color) + # self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + # self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + ################################### + + return vmags_df diff --git a/src/py_dss_tools/results/VTCDresults.py b/src/py_dss_tools/results/VTCDresults.py index 02edd5c..fa3aa27 100644 --- a/src/py_dss_tools/results/VTCDresults.py +++ b/src/py_dss_tools/results/VTCDresults.py @@ -5,77 +5,11 @@ # @Software: PyCharm from py_dss_interface import DSS -from py_dss_tools.dss_tools import DSSTools -import time -import pathlib +from py_dss_tools.results.VTCDSag import VTCDSag - -class VTCDresults: +class VTCDresults(VTCDSag): def __init__(self, dss: DSS): self._dss = dss - - def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95): - self._bus_fault = bus_fault - self._v_1 = v_1 - self._v_2 = v_2 - self._v_3 = v_3 - self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") - self._dss.text("solve") - vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() - vmags_df = vmags_df.iloc[:, :-1] #Descarta a última coluna. - vmags_df['vmin'] = vmags_df.min(axis=1) - - colors = [] - for v_min in vmags_df['vmin']: - if v_min < v_1: - colors.append("black") - elif v_min < v_2: - colors.append("red") - elif v_min < v_3: - colors.append("yellow") - else: - colors.append("green") - - vmags_df['colors'] = colors - - #o codigo abaixo inserir no VIEW - for index, row in vmags_df.iterrows(): - bus_name = index # Obtém o valor da primeira coluna (bus_name) - color = row.iloc[-1] # Obtém o valor da última coluna (color) - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - ###################################33 - - return vmags_df - - # estou trabalhando nesse código aqui para facilitar o acesso via o study example, mas no fim passarei ele para VtcdSagSwell. - - - - - - - - - - - - - - - # num_nodes = self._dss.bus.num_nodes #para barra com vários nós. - # nodes = self._dss.bus.nodes - # vmags = self._dss.bus.vmag_angle_pu[: 2 * num_nodes: 2] - # vangs = self._dss.bus.vmag_angle_pu[1: 2 * num_nodes: 2] - # return round(min(self._dss.bus.vmag_angle_pu[0:6:2]), 2) - - #disponibilizar aqui o - - - #Criar uma função nova aqui que aplica o curto em uma barra escolhida e chama a função que o Paulo criou no - #ResultsUtila que é a circuit_vmag_vang_dfs, assim terei um data frame com as tensões em todas as barras. - - - + VTCDSag.__init__(self, self._dss) diff --git a/src/py_dss_tools/results/VtcdSagSwell.py b/src/py_dss_tools/results/VtcdSagSwell.py deleted file mode 100644 index abc7ca2..0000000 --- a/src/py_dss_tools/results/VtcdSagSwell.py +++ /dev/null @@ -1,49 +0,0 @@ -from py_dss_interface import DSS -import time -from py_dss_tools.dss_utils import DSSUtils -import pathlib - - -class VtcdSagSwell: - - def __init__(self, dss: DSS): - self._dss = dss -def sag_df_3ph_sc(self, bus_fault, v_1=0.1, v_2=0.5, v_3=0.95): - self._bus_fault = bus_fault - self._v_1 = v_1 - self._v_2 = v_2 - self._v_3 = v_3 - self._dss.text(f"new fault.3_pf_{self._bus_fault} phases=3 bus1={self._bus_fault}") - self._dss.text("solve") -#estou trabalhando nesse código no VTCDresults, para facilitar, mas depois passarei tudo pra cá - vmags_df, vangs_df = DSSUtils(self._dss).results.circuit_vmag_vang_dfs() - - - - return vmags_df - - - - - - # bus_color_dict = dict() - # for bus in self._dss.circuit.buses_names: - # self._dss.circuit.set_active_bus(bus) - # if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas - # v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) - # - # if v_min < v_1: - # bus_color_dict[bus] = "black" - # elif v_min < v_2: - # bus_color_dict[bus] = "red" - # elif v_min < v_3: - # bus_color_dict[bus] = "yellow" - # else: - # bus_color_dict[bus] = "green" - # - # for bus_name, color in bus_color_dict.items(): - # self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - # - # self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - - diff --git a/src/py_dss_tools/view/VTCDSagCircuit.py b/src/py_dss_tools/view/VTCDSagCircuit.py new file mode 100644 index 0000000..fcd1893 --- /dev/null +++ b/src/py_dss_tools/view/VTCDSagCircuit.py @@ -0,0 +1,36 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : VTCDSagCircuit.py +# @Software: PyCharm + +from py_dss_interface import DSS +from py_dss_tools.results.VTCDresults import VTCDresults +# from py_dss_tools.results.VTCDSag import VTCDSag + + +class VTCDSagCircuit: + + def __init__(self, dss: DSS, results: VTCDresults): + self._results = results + self._dss = dss + + + def vtcd_sag_circuit(self): + + vmags_df = VTCDresults(self._dss).sag_3phsc_df_pu() #quero receber o vmags_df aqui, mas só vou executar essa função no main, após a execução da sag_3phsc_df_pu no main + # o main possui o nome de vtcd_study_exemple. + + + for index, row in vmags_df.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row.iloc[-1] # Obtém o valor da última coluna (color) + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + + + + # vmags_df = # aqui que não sei acessar o "vmags_df" que virá após a execução da função "sag_3phsc_df_pu", e obviamente eu irei executar + # essa "sag_3phsc_df_pu" primeiramente em meu script master. O que eu quero é chamar esse resultado "vmags_df" aqui para fazer + # o código abaixo. diff --git a/src/py_dss_tools/view/VTCDbusesNameTag.py b/src/py_dss_tools/view/VTCDbusesNameTag.py deleted file mode 100644 index ff4cc25..0000000 --- a/src/py_dss_tools/view/VTCDbusesNameTag.py +++ /dev/null @@ -1,22 +0,0 @@ -# -*- coding: utf-8 -*- -# @Author : Raphael Maccari -# @Email : raphaelmaccari@gmail.com -# @File : VTCDbusesNameTag.py -# @Software: PyCharm - -from py_dss_interface import DSS -from py_dss_tools.results.VTCDresults import VTCDresults - - -class VTCDbusesNameTag: - - def __init__(self, dss: DSS, results: VTCDresults): - self._results = results - self._dss = dss - - - def plot_circuit_buses_name(self): - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - - - diff --git a/src/py_dss_tools/view/ViewVTCDstudy.py b/src/py_dss_tools/view/ViewVTCDstudy.py index 3ac14b4..6abd954 100644 --- a/src/py_dss_tools/view/ViewVTCDstudy.py +++ b/src/py_dss_tools/view/ViewVTCDstudy.py @@ -4,15 +4,16 @@ # @File : ViewVTCDstudy.py # @Software: PyCharm -from py_dss_tools.view.VTCDbusesNameTag import VTCDbusesNameTag +from py_dss_tools.view.VTCDSagCircuit import VTCDSagCircuit from py_dss_interface import DSS from py_dss_tools.results.VTCDresults import VTCDresults -class ViewVTCDresults(VTCDbusesNameTag): +class ViewVTCDresults(VTCDSagCircuit): def __init__(self, dss: DSS, results: VTCDresults): - VTCDbusesNameTag.__init__(self, dss, results) + VTCDSagCircuit.__init__(self, dss, results) + # self._dss = dss #estava aqui, mas está tomando conta dentro da classe VTCbusesNameTag From 2c5051f60b7c407aeba719a93b7475779476e5f8 Mon Sep 17 00:00:00 2001 From: raphamac Date: Tue, 19 Mar 2024 20:19:31 -0300 Subject: [PATCH 06/11] Sag results and Sag view working good. --- examples/vtcd_study_exemple.py | 4 +-- src/py_dss_tools/results/VTCDSag.py | 15 +++++----- .../view/ShortCircuitImpedances.py | 1 + src/py_dss_tools/view/VTCDSagCircuit.py | 26 ++++++++--------- src/py_dss_tools/view/ViewVTCDstudy.py | 29 ------------------- 5 files changed, 23 insertions(+), 52 deletions(-) diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py index 7894372..de5d208 100644 --- a/examples/vtcd_study_exemple.py +++ b/examples/vtcd_study_exemple.py @@ -19,6 +19,6 @@ study.dss.text("batchedit regcontrol..* enabled=No") study.dss.text("batchedit load..* enabled=No") -study.results.sag_3phsc_df_pu("95") - +study.results.sag_3phsc_df_pu("95") #ver com o Paulo sobre as barras mono, pois curto 3ph em barra mono não está funcionando +study.view.vtcd_sag_circuit() print("here") diff --git a/src/py_dss_tools/results/VTCDSag.py b/src/py_dss_tools/results/VTCDSag.py index 85416b0..10cdac7 100644 --- a/src/py_dss_tools/results/VTCDSag.py +++ b/src/py_dss_tools/results/VTCDSag.py @@ -1,4 +1,8 @@ - +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : VTCDSag.py +# @Software: PyCharm import pandas as pd @@ -10,6 +14,7 @@ class VTCDSag: def __init__(self, dss: DSS): self._dss = dss + self.vmags_df = pd.DataFrame() def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95) -> pd.DataFrame: self._bus_fault = bus_fault @@ -35,12 +40,6 @@ def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95) -> pd.DataFrame: vmags_df['colors'] = colors - # Necessito que o codigo abaixo que utiliza o vmags_df acima seja executado em outro arquivo dentro de uma classe. - # for index, row in vmags_df.iterrows(): - # bus_name = index # Obtém o valor da primeira coluna (bus_name) - # color = row.iloc[-1] # Obtém o valor da última coluna (color) - # self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - # self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - ################################### + self.vmags_df = vmags_df return vmags_df diff --git a/src/py_dss_tools/view/ShortCircuitImpedances.py b/src/py_dss_tools/view/ShortCircuitImpedances.py index fe7a340..0f7bade 100644 --- a/src/py_dss_tools/view/ShortCircuitImpedances.py +++ b/src/py_dss_tools/view/ShortCircuitImpedances.py @@ -19,6 +19,7 @@ def __init__(self, dss: DSS, results: FaultResults): self._plot_style = CustomPlotStyle() + @property def short_circuit_impedances_plot_style(self): return self._plot_style diff --git a/src/py_dss_tools/view/VTCDSagCircuit.py b/src/py_dss_tools/view/VTCDSagCircuit.py index fcd1893..b255a10 100644 --- a/src/py_dss_tools/view/VTCDSagCircuit.py +++ b/src/py_dss_tools/view/VTCDSagCircuit.py @@ -5,32 +5,32 @@ # @Software: PyCharm from py_dss_interface import DSS -from py_dss_tools.results.VTCDresults import VTCDresults -# from py_dss_tools.results.VTCDSag import VTCDSag +from py_dss_tools.results import VTCDresults class VTCDSagCircuit: - def __init__(self, dss: DSS, results: VTCDresults): + # def __init__(self, dss: DSS, results = None): + def __init__(self, dss: DSS, results): + # def __init__(self, dss: DSS, results: VTCDresults): #Qualquer um dos 2 def acima dá certo. Troquei para results: VTCDSag e fiz o import do VTCDSag lá em cima. self._results = results self._dss = dss + self.vmags_df = None def vtcd_sag_circuit(self): - vmags_df = VTCDresults(self._dss).sag_3phsc_df_pu() #quero receber o vmags_df aqui, mas só vou executar essa função no main, após a execução da sag_3phsc_df_pu no main - # o main possui o nome de vtcd_study_exemple. + if self._results is None: + raise ValueError("VTCDresults object not set. Call set_results method first.") + vmags_df_circuit = self._results.vmags_df # também dá certo sem o import e com o dito lá no init "results=None". - for index, row in vmags_df.iterrows(): + if vmags_df_circuit.empty: + raise ValueError("vmags_df is empty. Run sag_3phsc_df_pu method first.") + + # for index, row in self._results.vmags_df.iterrows(): # Esse também dá certo !!! + for index, row in vmags_df_circuit.iterrows(): bus_name = index # Obtém o valor da primeira coluna (bus_name) color = row.iloc[-1] # Obtém o valor da última coluna (color) self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - - - - - # vmags_df = # aqui que não sei acessar o "vmags_df" que virá após a execução da função "sag_3phsc_df_pu", e obviamente eu irei executar - # essa "sag_3phsc_df_pu" primeiramente em meu script master. O que eu quero é chamar esse resultado "vmags_df" aqui para fazer - # o código abaixo. diff --git a/src/py_dss_tools/view/ViewVTCDstudy.py b/src/py_dss_tools/view/ViewVTCDstudy.py index 6abd954..8b1a2b6 100644 --- a/src/py_dss_tools/view/ViewVTCDstudy.py +++ b/src/py_dss_tools/view/ViewVTCDstudy.py @@ -13,32 +13,3 @@ class ViewVTCDresults(VTCDSagCircuit): def __init__(self, dss: DSS, results: VTCDresults): VTCDSagCircuit.__init__(self, dss, results) - - - - # self._dss = dss #estava aqui, mas está tomando conta dentro da classe VTCbusesNameTag - # self._results = results #estava aqui, mas está tomando conta dentro da classe VTCbusesNameTag - - - # def plot_circuit_buses_name_tag(self): # passei essa função para a classe VTCbusesNameTag, pois neste aquivo - # herdarei cada arquivo de funcionalidade que for criado. - # self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - - - - - - - - # PlotCircuitBusesNameTag.__init__(self, dss, results) - - -# from py_dss_tools.results.FaultResults import FaultResults -# from py_dss_tools.view.ShortCircuitImpedances import ShortCircuitImpedances -# from py_dss_interface import DSS -# -# -# class ViewFaultResults(ShortCircuitImpedances): -# -# def __init__(self, dss: DSS, results: FaultResults): -# ShortCircuitImpedances.__init__(self, dss, results) From dedccd5ff2b0908c49af96c5a57b1937a4c69eaa Mon Sep 17 00:00:00 2001 From: raphamac Date: Tue, 19 Mar 2024 22:29:05 -0300 Subject: [PATCH 07/11] VTCDSagSwell results and view for 1ph short-circuit created and working. --- examples/vtcd_study_exemple.py | 8 ++- src/py_dss_tools/results/VTCDSagSwell.py | 64 ++++++++++++++++++++ src/py_dss_tools/results/VTCDresults.py | 4 +- src/py_dss_tools/view/VTCDSagSwellCircuit.py | 44 ++++++++++++++ src/py_dss_tools/view/ViewVTCDstudy.py | 5 +- 5 files changed, 121 insertions(+), 4 deletions(-) create mode 100644 src/py_dss_tools/results/VTCDSagSwell.py create mode 100644 src/py_dss_tools/view/VTCDSagSwellCircuit.py diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py index de5d208..8a14b09 100644 --- a/examples/vtcd_study_exemple.py +++ b/examples/vtcd_study_exemple.py @@ -19,6 +19,10 @@ study.dss.text("batchedit regcontrol..* enabled=No") study.dss.text("batchedit load..* enabled=No") -study.results.sag_3phsc_df_pu("95") #ver com o Paulo sobre as barras mono, pois curto 3ph em barra mono não está funcionando -study.view.vtcd_sag_circuit() +# study.results.sag_3phsc_df_pu("95") #ver com o Paulo sobre as barras mono, pois curto 3ph em barra mono não está funcionando +# study.view.vtcd_sag_circuit() + +study.results.sag_swell_1phsc_df_pu("95") +study.view.vtcd_sag_swell_circuit() + print("here") diff --git a/src/py_dss_tools/results/VTCDSagSwell.py b/src/py_dss_tools/results/VTCDSagSwell.py new file mode 100644 index 0000000..9ee479a --- /dev/null +++ b/src/py_dss_tools/results/VTCDSagSwell.py @@ -0,0 +1,64 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : VTCDSagSwell.py +# @Software: PyCharm + + +import pandas as pd +from py_dss_interface import DSS +from py_dss_tools.dss_tools import DSSTools + + +class VTCDSagSwell: + + def __init__(self, dss: DSS): + self._dss = dss + self.vmags_df = pd.DataFrame() + + def sag_swell_1phsc_df_pu(self, bus_fault, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vswell_1=1.05, + vswell_2=1.06, vswell_3=1.1) -> pd.DataFrame: + self._bus_fault = bus_fault + self._vsag_1 = vsag_1 + self._vsag_2 = vsag_2 + self._vsag_3 = vsag_3 + self._vswell_1 = vswell_1 + self._vswell_2 = vswell_2 + self._vswell_3 = vswell_3 + self._dss.text(f"new fault.1_ph_{self._bus_fault} phases=1 bus1={self._bus_fault}.1 bus2={self._bus_fault}.0") + self._dss.text("solve") + + + vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + vmags_df['vmin'] = vmags_df.min(axis=1) + vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1) + + colors_sag = [] + for v_min in vmags_df['vmin']: + if v_min < vsag_1: + colors_sag.append("black") + elif v_min < vsag_2: + colors_sag.append("red") + elif v_min < vsag_3: + colors_sag.append("yellow") + else: + colors_sag.append("green") + + vmags_df['colors_sag'] = colors_sag + + colors_swell = [] + for v_max in vmags_df['vmax']: + if v_max <= vswell_1: + colors_swell.append("green") + elif v_max <= vswell_2: + colors_swell.append("yellow") + elif v_max <= vswell_3: + colors_swell.append("red") + else: + colors_swell.append("black") + + vmags_df['colors_swell'] = colors_swell + + self.vmags_df = vmags_df + + return vmags_df diff --git a/src/py_dss_tools/results/VTCDresults.py b/src/py_dss_tools/results/VTCDresults.py index fa3aa27..1e35030 100644 --- a/src/py_dss_tools/results/VTCDresults.py +++ b/src/py_dss_tools/results/VTCDresults.py @@ -6,10 +6,12 @@ from py_dss_interface import DSS from py_dss_tools.results.VTCDSag import VTCDSag +from py_dss_tools.results.VTCDSagSwell import VTCDSagSwell -class VTCDresults(VTCDSag): +class VTCDresults(VTCDSag, VTCDSagSwell): def __init__(self, dss: DSS): self._dss = dss VTCDSag.__init__(self, self._dss) + VTCDSagSwell.__init__(self, self._dss) diff --git a/src/py_dss_tools/view/VTCDSagSwellCircuit.py b/src/py_dss_tools/view/VTCDSagSwellCircuit.py new file mode 100644 index 0000000..df05273 --- /dev/null +++ b/src/py_dss_tools/view/VTCDSagSwellCircuit.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : VTCDSagCircuit.py +# @Software: PyCharm + +from py_dss_interface import DSS +from py_dss_tools.results import VTCDresults +import time + + +class VTCDSagSwellCircuit: + + def __init__(self, dss: DSS, results: VTCDresults): + self._results = results + self._dss = dss + self.vmags_df = None + + + def vtcd_sag_swell_circuit(self): + + if self._results is None: + raise ValueError("VTCDresults object not set. Call set_results method first.") + + vmags_df_circuit = self._results.vmags_df + + if vmags_df_circuit.empty: + raise ValueError("vmags_df is empty. Run sag_swell_1phsc_df_pu method first.") + + for index, row in vmags_df_circuit.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row['colors_sag'] # Obtém o valor da coluna "colors_sag" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + time.sleep(1) + + self._dss.text(f"ClearBusMarkers") # Fiz isso não repetir os + + for index, row in vmags_df_circuit.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row['colors_swell'] # Obtém o valor da coluna "colors_swell" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") diff --git a/src/py_dss_tools/view/ViewVTCDstudy.py b/src/py_dss_tools/view/ViewVTCDstudy.py index 8b1a2b6..c43d2e1 100644 --- a/src/py_dss_tools/view/ViewVTCDstudy.py +++ b/src/py_dss_tools/view/ViewVTCDstudy.py @@ -5,11 +5,14 @@ # @Software: PyCharm from py_dss_tools.view.VTCDSagCircuit import VTCDSagCircuit +from py_dss_tools.view.VTCDSagSwellCircuit import VTCDSagSwellCircuit from py_dss_interface import DSS from py_dss_tools.results.VTCDresults import VTCDresults -class ViewVTCDresults(VTCDSagCircuit): + +class ViewVTCDresults(VTCDSagCircuit, VTCDSagSwellCircuit): def __init__(self, dss: DSS, results: VTCDresults): VTCDSagCircuit.__init__(self, dss, results) + VTCDSagSwellCircuit.__init__(self, dss, results) From 2dee702a59eaa74080dd5126caa0be9b4b27d72e Mon Sep 17 00:00:00 2001 From: raphamac Date: Mon, 25 Mar 2024 01:34:54 -0300 Subject: [PATCH 08/11] =?UTF-8?q?VTCDVulnerabilityArea=20included,=20but?= =?UTF-8?q?=20it=C2=B4s=20not=20working=20very=20well,=20it=20is=20necessa?= =?UTF-8?q?ry=20to=20review.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- examples/vtcd_study_exemple.py | 6 +- src/py_dss_tools/results/BckupFuncoes.py | 50 ++++++++++ .../results/VTCDVulnerabilityArea.py | 94 +++++++++++++++++++ src/py_dss_tools/results/VTCDresults.py | 4 +- 4 files changed, 151 insertions(+), 3 deletions(-) create mode 100644 src/py_dss_tools/results/VTCDVulnerabilityArea.py diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py index 8a14b09..59c079b 100644 --- a/examples/vtcd_study_exemple.py +++ b/examples/vtcd_study_exemple.py @@ -22,7 +22,9 @@ # study.results.sag_3phsc_df_pu("95") #ver com o Paulo sobre as barras mono, pois curto 3ph em barra mono não está funcionando # study.view.vtcd_sag_circuit() -study.results.sag_swell_1phsc_df_pu("95") -study.view.vtcd_sag_swell_circuit() +# study.results.sag_swell_1phsc_df_pu("95") +# study.view.vtcd_sag_swell_circuit() + +study.results.bus_vulnerability_sag_map_sc3ph("52", dss_file) print("here") diff --git a/src/py_dss_tools/results/BckupFuncoes.py b/src/py_dss_tools/results/BckupFuncoes.py index f7e2e11..0dae001 100644 --- a/src/py_dss_tools/results/BckupFuncoes.py +++ b/src/py_dss_tools/results/BckupFuncoes.py @@ -169,3 +169,53 @@ def bus_vulnerability_sag_map_sc3ph(self, dss_file: str, bus_analyzed, v_1=0.1, self._dss.text("plot circuit Power max=2000 y n C1=$00FF0000") + +class VTCDVunerabilityArea: + + def __init__(self, dss: DSS): + self._dss = dss + + + def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0.5, v_3=0.95): + self._bus_analyzed = bus_analyzed + self._v_1 = v_1 + self._v_2 = v_2 + self._v_3 = v_3 + self.dss_file = dss_file + + bus_names = list() + for bus in self._dss.circuit.buses_names: + self._dss.circuit.set_active_bus(bus) + if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: + bus_names.append(bus) + + bus_color_dict = dict() + for bus in bus_names: + + self._dss.text(f"Compile [{self.dss_file}]") + + self._dss.text("batchedit regcontrol..* enabled=No") + self._dss.text("batchedit load..* enabled=No") + self._dss.text(f"Buscoords Buscoords.dat") + self._dss.text(f"new fault.3_ph phases=3 bus1={bus}") + self._dss.text("solve") + + self._dss.circuit.set_active_bus(self._bus_analyzed) + + v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) + + if v_min < v_1: + bus_color_dict[bus] = "black" + elif v_min < v_2: + bus_color_dict[bus] = "red" + elif v_min < v_3: + bus_color_dict[bus] = "yellow" + else: + print(v_min) + bus_color_dict[bus] = "green" + + for bus_name, color in bus_color_dict.items(): + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + diff --git a/src/py_dss_tools/results/VTCDVulnerabilityArea.py b/src/py_dss_tools/results/VTCDVulnerabilityArea.py new file mode 100644 index 0000000..8a13429 --- /dev/null +++ b/src/py_dss_tools/results/VTCDVulnerabilityArea.py @@ -0,0 +1,94 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : VTCDVulnerabilityArea.py +# @Software: PyCharm + + +import pandas as pd +from py_dss_interface import DSS +from py_dss_tools.dss_tools import DSSTools + + +class VTCDVunerabilityArea: + + def __init__(self, dss: DSS): + self._dss = dss + self.vmags_df = pd.DataFrame() + + + def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0.5, v_3=0.95): + self._bus_analyzed = bus_analyzed + self._v_1 = v_1 + self._v_2 = v_2 + self._v_3 = v_3 + self.dss_file = dss_file + +#### Não funciona bem para as barras monofásicas. Ver com o Paulo algo para melhorar ou fazer a exclusão das mono, icluir todas somente no sag swell. +#### Fiz um if else para radar curtos mono para barras mono, mas causa sobretensão em algumas barras, ver com o Paulo pois não faz sentido fazer uma função +#### só para sag 3ph e outra para mono, tavez colocar aqui os critérios???? Mas não sei quais. Ou deixar sem mesmo e avisar o usuário que são barras mono e +#### não se aplica este estudo para barras mono. + + vmags_df, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + # vmags_df['node4'] = None + + # values = [] # Criei esse para melhorar a lentidão, mas deu na mesma com a lista. + for bus in self._dss.circuit.buses_names: + + self._dss.text(f"Compile [{self.dss_file}]") + self._dss.text("batchedit regcontrol..* enabled=No") + self._dss.text("batchedit load..* enabled=No") + self._dss.text(f"Buscoords Buscoords.dat") + + self._dss.circuit.set_active_bus(bus) + if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: + self._dss.text(f"new fault.3_ph_{bus} phases=3 bus1={bus} bus2={bus}.4.4.4") + self._dss.text("solve") + vmags_df_temp, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + vmags_df_temp = vmags_df_temp.iloc[:, :-1] # Descarta a última coluna. + vmags_df.loc[bus] = vmags_df_temp.loc[self._bus_analyzed].values + + else: + self._dss.text(f"new fault.1_ph_{bus} phases=1 bus1={bus}.1 bus2={bus}.0") + self._dss.text("solve") + vmags_df_temp, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + vmags_df.loc[bus] = vmags_df_temp.loc[self._bus_analyzed].values + + # vmags_df_temp, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + + # values.append(vmags_df_temp.loc[self._bus_analyzed].values) # Criei esse para melhorar a lentidão, mas deu na mesma com a lista. + + # vmags_df.loc[bus] = vmags_df_temp.loc[self._bus_analyzed].values ### Essa linha funcionou. + + # vmags_df.iloc[:, :] = values # Criei esse para melhorar a lentidão, mas deu na mesma com a lista. + + # vmags_df = vmags_df.iloc[:, :-1] + vmags_df['vmin'] = vmags_df.min(axis=1) # Gera uma coluna no df com nome vmin e armazena o mínimo das 3 anteriores. + +###### Ficou lento o código, mas deu na mesma com a lista. + + colors = [] + for v_min in vmags_df['vmin']: + if v_min < v_1: + colors.append("black") + elif v_min < v_2: + colors.append("red") + elif v_min < v_3: + colors.append("yellow") + else: + colors.append("green") + + vmags_df['colors'] = colors + self.vmags_df = vmags_df + + +##### passar o código abaixo para o view + for index, row in vmags_df.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row.iloc[-1] # Obtém o valor da última coluna (color) + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") +################ + + return vmags_df + diff --git a/src/py_dss_tools/results/VTCDresults.py b/src/py_dss_tools/results/VTCDresults.py index 1e35030..3d0468a 100644 --- a/src/py_dss_tools/results/VTCDresults.py +++ b/src/py_dss_tools/results/VTCDresults.py @@ -7,11 +7,13 @@ from py_dss_interface import DSS from py_dss_tools.results.VTCDSag import VTCDSag from py_dss_tools.results.VTCDSagSwell import VTCDSagSwell +from py_dss_tools.results.VTCDVulnerabilityArea import VTCDVunerabilityArea -class VTCDresults(VTCDSag, VTCDSagSwell): +class VTCDresults(VTCDSag, VTCDSagSwell,VTCDVunerabilityArea): def __init__(self, dss: DSS): self._dss = dss VTCDSag.__init__(self, self._dss) VTCDSagSwell.__init__(self, self._dss) + VTCDVunerabilityArea.__init__(self, self._dss) From ba1fed7a731f231065e1a24ccc34e6b2be3bf2c8 Mon Sep 17 00:00:00 2001 From: raphamac Date: Mon, 1 Apr 2024 20:42:22 -0300 Subject: [PATCH 09/11] Vulnerability Area added. --- examples/vtcd_study_exemple.py | 9 ++- src/py_dss_tools/results/VTCDSagSwell.py | 4 +- .../results/VTCDVulnerabilityArea.py | 64 ++++++++++++++++--- src/py_dss_tools/view/VTCDSagSwellCircuit.py | 2 +- .../view/VTCDVulnerabilityCircuit.py | 64 +++++++++++++++++++ src/py_dss_tools/view/ViewVTCDstudy.py | 4 +- 6 files changed, 132 insertions(+), 15 deletions(-) create mode 100644 src/py_dss_tools/view/VTCDVulnerabilityCircuit.py diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py index 59c079b..ac05aeb 100644 --- a/examples/vtcd_study_exemple.py +++ b/examples/vtcd_study_exemple.py @@ -19,12 +19,15 @@ study.dss.text("batchedit regcontrol..* enabled=No") study.dss.text("batchedit load..* enabled=No") -# study.results.sag_3phsc_df_pu("95") #ver com o Paulo sobre as barras mono, pois curto 3ph em barra mono não está funcionando -# study.view.vtcd_sag_circuit() +study.results.sag_3phsc_df_pu("95") #ver com o Paulo sobre as barras mono, pois curto 3ph em barra mono não está funcionando +study.view.vtcd_sag_circuit() # study.results.sag_swell_1phsc_df_pu("95") # study.view.vtcd_sag_swell_circuit() -study.results.bus_vulnerability_sag_map_sc3ph("52", dss_file) +# study.results.bus_vulnerability_sag_map_sc3ph("52", dss_file) +# study.view.vtcd_vulnerability_circuit_sc3ph() +# study.results.bus_vulnerability_sag_swell_map_sc1ph("52", dss_file) +# study.view.vtcd_vulnerability_circuit_sc1ph() print("here") diff --git a/src/py_dss_tools/results/VTCDSagSwell.py b/src/py_dss_tools/results/VTCDSagSwell.py index 9ee479a..68962e0 100644 --- a/src/py_dss_tools/results/VTCDSagSwell.py +++ b/src/py_dss_tools/results/VTCDSagSwell.py @@ -30,8 +30,8 @@ def sag_swell_1phsc_df_pu(self, bus_fault, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() - vmags_df['vmin'] = vmags_df.min(axis=1) - vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1) + vmags_df['vmin'] = vmags_df.min(axis=1) #Cria uma coluna adicional e faz o mínimo das 3 anteriores. + vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1)#Cria uma coluna adicional e faz o máximo das 3 primeiras colors_sag = [] for v_min in vmags_df['vmin']: diff --git a/src/py_dss_tools/results/VTCDVulnerabilityArea.py b/src/py_dss_tools/results/VTCDVulnerabilityArea.py index 8a13429..de7faa5 100644 --- a/src/py_dss_tools/results/VTCDVulnerabilityArea.py +++ b/src/py_dss_tools/results/VTCDVulnerabilityArea.py @@ -81,14 +81,62 @@ def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0 vmags_df['colors'] = colors self.vmags_df = vmags_df + return vmags_df + + def bus_vulnerability_sag_swell_map_sc1ph(self, bus_analyzed, dss_file, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vswell_1=1.05, + vswell_2=1.06, vswell_3=1.1): + self._bus_analyzed = bus_analyzed + self._vsag_1 = vsag_1 + self._vsag_2 = vsag_2 + self._vsag_3 = vsag_3 + self._vswell_1 = vswell_1 + self._vswell_2 = vswell_2 + self._vswell_3 = vswell_3 + self.dss_file = dss_file -##### passar o código abaixo para o view - for index, row in vmags_df.iterrows(): - bus_name = index # Obtém o valor da primeira coluna (bus_name) - color = row.iloc[-1] # Obtém o valor da última coluna (color) - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") -################ + vmags_df, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() - return vmags_df + for bus in self._dss.circuit.buses_names: + + self._dss.text(f"Compile [{self.dss_file}]") + self._dss.text("batchedit regcontrol..* enabled=No") + self._dss.text("batchedit load..* enabled=No") + self._dss.text(f"Buscoords Buscoords.dat") + self._dss.text(f"new fault.1_ph_{bus} phases=1 bus1={bus}.1 bus2={bus}.0") + self._dss.text("solve") + vmags_df_temp, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() + vmags_df.loc[bus] = vmags_df_temp.loc[self._bus_analyzed].values + + vmags_df['vmin'] = vmags_df.min(axis=1) # Gera uma coluna no df com nome vmin e armazena o mínimo das 3 anteriores. + vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1) # Cria uma coluna adicional e faz o máximo das 3 primeiras + + colors_sag = [] + for v_min in vmags_df['vmin']: + if v_min < vsag_1: + colors_sag.append("black") + elif v_min < vsag_2: + colors_sag.append("red") + elif v_min < vsag_3: + colors_sag.append("yellow") + else: + colors_sag.append("green") + + vmags_df['colors_sag'] = colors_sag + + colors_swell = [] + for v_max in vmags_df['vmax']: + if v_max <= vswell_1: + colors_swell.append("green") + elif v_max <= vswell_2: + colors_swell.append("yellow") + elif v_max <= vswell_3: + colors_swell.append("red") + else: + colors_swell.append("black") + + vmags_df['colors_swell'] = colors_swell + + self.vmags_df = vmags_df + + return vmags_df diff --git a/src/py_dss_tools/view/VTCDSagSwellCircuit.py b/src/py_dss_tools/view/VTCDSagSwellCircuit.py index df05273..b6d9f4c 100644 --- a/src/py_dss_tools/view/VTCDSagSwellCircuit.py +++ b/src/py_dss_tools/view/VTCDSagSwellCircuit.py @@ -35,7 +35,7 @@ def vtcd_sag_swell_circuit(self): time.sleep(1) - self._dss.text(f"ClearBusMarkers") # Fiz isso não repetir os + self._dss.text(f"ClearBusMarkers") # Fiz isso não repetir as cores for index, row in vmags_df_circuit.iterrows(): bus_name = index # Obtém o valor da primeira coluna (bus_name) diff --git a/src/py_dss_tools/view/VTCDVulnerabilityCircuit.py b/src/py_dss_tools/view/VTCDVulnerabilityCircuit.py new file mode 100644 index 0000000..fb12d6b --- /dev/null +++ b/src/py_dss_tools/view/VTCDVulnerabilityCircuit.py @@ -0,0 +1,64 @@ +# -*- coding: utf-8 -*- +# @Author : Raphael Maccari +# @Email : raphaelmaccari@gmail.com +# @File : VTCDVulnerabilityCircuit.py +# @Software: PyCharm + +from py_dss_interface import DSS +from py_dss_tools.results import VTCDresults +import time + + +class VTCDVulnerabilityCircuit: + + # def __init__(self, dss: DSS, results = None): + def __init__(self, dss: DSS, results): + # def __init__(self, dss: DSS, results: VTCDresults): #Qualquer um dos 2 def acima dá certo. Troquei para results: VTCDSag e fiz o import do VTCDSag lá em cima. + self._results = results + self._dss = dss + self.vmags_df = None + + + def vtcd_vulnerability_circuit_sc3ph(self): + + if self._results is None: + raise ValueError("VTCDresults object not set. Call set_results method first.") + + vmags_df_circuit = self._results.vmags_df # também dá certo sem o import e com o dito lá no init "results=None". + + if vmags_df_circuit.empty: + raise ValueError("vmags_df is empty. Run vulnerability_sag_map_sc3ph method first.") + + # for index, row in self._results.vmags_df.iterrows(): # Esse também dá certo !!! + for index, row in vmags_df_circuit.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row.iloc[-1] # Obtém o valor da última coluna (color) + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + def vtcd_vulnerability_circuit_sc1ph(self): + + if self._results is None: + raise ValueError("VTCDresults object not set. Call set_results method first.") + + vmags_df_circuit = self._results.vmags_df # também dá certo sem o import e com o dito lá no init "results=None". + + if vmags_df_circuit.empty: + raise ValueError("vmags_df is empty. Run vulnerability_sag_map_sc1ph method first.") + + # for index, row in self._results.vmags_df.iterrows(): # Esse também dá certo !!! + for index, row in vmags_df_circuit.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row['colors_sag'] # Obtém o valor da coluna "colors_sag" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + + time.sleep(1) + + self._dss.text(f"ClearBusMarkers") # Fiz isso não repetir as cores + + for index, row in vmags_df_circuit.iterrows(): + bus_name = index # Obtém o valor da primeira coluna (bus_name) + color = row['colors_swell'] # Obtém o valor da coluna "colors_swell" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") diff --git a/src/py_dss_tools/view/ViewVTCDstudy.py b/src/py_dss_tools/view/ViewVTCDstudy.py index c43d2e1..80c7bd0 100644 --- a/src/py_dss_tools/view/ViewVTCDstudy.py +++ b/src/py_dss_tools/view/ViewVTCDstudy.py @@ -6,13 +6,15 @@ from py_dss_tools.view.VTCDSagCircuit import VTCDSagCircuit from py_dss_tools.view.VTCDSagSwellCircuit import VTCDSagSwellCircuit +from py_dss_tools.view.VTCDVulnerabilityCircuit import VTCDVulnerabilityCircuit from py_dss_interface import DSS from py_dss_tools.results.VTCDresults import VTCDresults -class ViewVTCDresults(VTCDSagCircuit, VTCDSagSwellCircuit): +class ViewVTCDresults(VTCDSagCircuit, VTCDSagSwellCircuit, VTCDVulnerabilityCircuit): def __init__(self, dss: DSS, results: VTCDresults): VTCDSagCircuit.__init__(self, dss, results) VTCDSagSwellCircuit.__init__(self, dss, results) + VTCDVulnerabilityCircuit.__init__(self, dss, results) From 8ed8766763961cb9dec2860ec3a8787717063759 Mon Sep 17 00:00:00 2001 From: raphamac Date: Thu, 27 Jun 2024 21:52:24 -0300 Subject: [PATCH 10/11] Final Version jun24 --- examples/vtcd_study_exemple.py | 18 +- src/py_dss_tools/results/BckupFuncoes.py | 221 ------------------ src/py_dss_tools/results/VTCDSagSwell.py | 2 +- .../results/VTCDVulnerabilityArea.py | 22 +- src/py_dss_tools/studies/StudyVTCD.py | 12 +- src/py_dss_tools/view/VTCDSagCircuit.py | 12 +- src/py_dss_tools/view/VTCDSagSwellCircuit.py | 24 +- .../view/VTCDVulnerabilityCircuit.py | 43 ++-- 8 files changed, 62 insertions(+), 292 deletions(-) delete mode 100644 src/py_dss_tools/results/BckupFuncoes.py diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py index ac05aeb..8011a42 100644 --- a/examples/vtcd_study_exemple.py +++ b/examples/vtcd_study_exemple.py @@ -19,15 +19,19 @@ study.dss.text("batchedit regcontrol..* enabled=No") study.dss.text("batchedit load..* enabled=No") -study.results.sag_3phsc_df_pu("95") #ver com o Paulo sobre as barras mono, pois curto 3ph em barra mono não está funcionando +study.results.sag_3phsc_df_pu("95") study.view.vtcd_sag_circuit() -# study.results.sag_swell_1phsc_df_pu("95") -# study.view.vtcd_sag_swell_circuit() +study.results.sag_swell_1phsc_df_pu("95") +study.view.vtcd_sag_swell_circuit() -# study.results.bus_vulnerability_sag_map_sc3ph("52", dss_file) -# study.view.vtcd_vulnerability_circuit_sc3ph() -# study.results.bus_vulnerability_sag_swell_map_sc1ph("52", dss_file) -# study.view.vtcd_vulnerability_circuit_sc1ph() +study.results.bus_vulnerability_sag_map_sc3ph("52", dss_file) +study.view.vtcd_vulnerability_circuit_sc3ph() + +study.results.bus_vulnerability_sag_swell_map_sc1ph("52", dss_file) +study.view.vtcd_vulnerability_circuit_sc1ph() print("here") + + + diff --git a/src/py_dss_tools/results/BckupFuncoes.py b/src/py_dss_tools/results/BckupFuncoes.py deleted file mode 100644 index 0dae001..0000000 --- a/src/py_dss_tools/results/BckupFuncoes.py +++ /dev/null @@ -1,221 +0,0 @@ -from py_dss_interface import DSS -import time -from py_dss_tools.dss_utils import DSSUtils -import pathlib - - -class VTCDresults: - - def __init__(self, dss: DSS): - self._dss = dss - - # Criar uma função nova aqui que aplica o curto em uma barra escolhida e chama a função que o Paulo criou no - # ResultsUtila que é a circuit_vmag_vang_dfs, assim terei um data frame com as tensões em todas as barras. - - - def sag_3phsc_df_pu(self, bus_fault): - self._bus_fault = bus_fault - self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") - self._dss.text("solve") - vmags_df, vangs_df = DSSUtils(self._dss).get_circuit_vmag_vang_dfs() - return vmags_df, vangs_df - - def sag3ph_pu(self, bus_fault, bus_sag): - self._bus_fault = bus_fault - self._bus_sag = bus_sag - self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") - self._dss.text("solve") - self._dss.circuit.set_active_bus(self._bus_sag) - # num_nodes = self._dss.bus.num_nodes #para barra com vários nós. - # nodes = self._dss.bus.nodes - # vmags = self._dss.bus.vmag_angle_pu[: 2 * num_nodes: 2] - # vangs = self._dss.bus.vmag_angle_pu[1: 2 * num_nodes: 2] - return round(min(self._dss.bus.vmag_angle_pu[0:6:2]), 2) - - def sag_swell_1ph_pu(self, bus_fault, bus_sag_swel): - self._bus_fault = bus_fault - self._bus_sag_swell = bus_sag_swel - self._dss.text(f"new fault.1_ph_{self._bus_fault} phases=1 bus1={self._bus_fault}.1 bus2={self._bus_fault}.0") - self._dss.text("solve") - self._dss.circuit.set_active_bus(self._bus_sag_swell) - return round(min(self._dss.bus.vmag_angle_pu[0:6:2]), 2), round(max(self._dss.bus.vmag_angle_pu[0:6:2]), 2) - - def sag_map_3ph_buses_3ph_sc(self, bus_fault, v_1=0.1, v_2=0.5, v_3=0.95): - self._bus_fault = bus_fault - self._v_1 = v_1 - self._v_2 = v_2 - self._v_3 = v_3 - self._dss.text(f"new fault.3_pf_{self._bus_fault} phases=3 bus1={self._bus_fault}") - self._dss.text("solve") - - bus_color_dict = dict() - for bus in self._dss.circuit.buses_names: - self._dss.circuit.set_active_bus(bus) - if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas - v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) - - if v_min < v_1: - bus_color_dict[bus] = "black" - elif v_min < v_2: - bus_color_dict[bus] = "red" - elif v_min < v_3: - bus_color_dict[bus] = "yellow" - else: - bus_color_dict[bus] = "green" - - for bus_name, color in bus_color_dict.items(): - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - - def sag_swell_maps_1ph_buses_3ph_sc(self, bus_fault, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vswell_1=1.05, - vswell_2=1.06, vswell_3=1.1): - self._bus_fault = bus_fault - self._vsag_1 = vsag_1 - self._vsag_2 = vsag_2 - self._vsag_3 = vsag_3 - self._vswell_1 = vswell_1 - self._vswell_2 = vswell_2 - self._vswell_3 = vswell_3 - self._dss.text(f"new fault.1_ph_{self._bus_fault} phases=1 bus1={self._bus_fault}.1 bus2={self._bus_fault}.0") - self._dss.text("solve") - - bus_color_dict_sag = dict() - for bus in self._dss.circuit.buses_names: - self._dss.circuit.set_active_bus(bus) - if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas - v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) - - if v_min < vsag_1: - bus_color_dict_sag[bus] = "black" - elif v_min < vsag_2: - bus_color_dict_sag[bus] = "red" - elif v_min < vsag_3: - bus_color_dict_sag[bus] = "yellow" - else: - bus_color_dict_sag[bus] = "green" - - for bus_name, color in bus_color_dict_sag.items(): - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - - self._dss.text("plot circuit Power max=2000 y y C1=$00FF0000") - - # Tempo em segundos para interromper a execução - tempo_de_parada = 1 # Alterei para a quantidade desejada de segundos - time.sleep(tempo_de_parada) - - bus_color_dict_swell = dict() - for bus in self._dss.circuit.buses_names: - self._dss.circuit.set_active_bus(bus) - if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: # Resultados somente para barras trifásicas - v_max = max(self._dss.bus.vmag_angle_pu[0:6:2]) - - if v_max <= vswell_1: - bus_color_dict_swell[bus] = "green" - elif v_max <= vswell_2: - bus_color_dict_swell[bus] = "yellow" - elif v_max <= vswell_3: - bus_color_dict_swell[bus] = "red" - else: - bus_color_dict_swell[bus] = "black" - for bus_name, color in bus_color_dict_swell.items(): - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - - # def compile_dss(self, dss_file: str): - # self._dss.text("ClearAll") - # self._dss.text("Compile " + "[" + dss_file + "]") - - def bus_vulnerability_sag_map_sc3ph(self, dss_file: str, bus_analyzed, v_1=0.1, v_2=0.5, v_3=0.95): - self._bus_analyzed = bus_analyzed - self._v_1 = v_1 - self._v_2 = v_2 - self._v_3 = v_3 - - bus_names = list() - for bus in self._dss.circuit.buses_names: - self._dss.circuit.set_active_bus(bus) - if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: - bus_names.append(bus) - - bus_color_dict = dict() - for bus in bus_names: - # self._dss.text("Compile C:/RaphaelMaccari/GitHub/py-dss-tools/examples/feeders/123Bus/IEEE123Master.dss") - self._dss.text(f"Compile [{dss_file}]") - # pensar como fazer o compile com o link automático do aquivo. - - self._dss.text("batchedit regcontrol..* enabled=No") - self._dss.text("batchedit load..* enabled=No") - self._dss.text(f"Buscoords Buscoords.dat") - self._dss.text(f"new fault.3_ph phases=3 bus1={bus}") - self._dss.text("solve") - - self._dss.circuit.set_active_bus(self._bus_analyzed) - - v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) - - if v_min < v_1: - bus_color_dict[bus] = "black" - elif v_min < v_2: - bus_color_dict[bus] = "red" - elif v_min < v_3: - bus_color_dict[bus] = "yellow" - else: - print(v_min) - bus_color_dict[bus] = "green" - - for bus_name, color in bus_color_dict.items(): - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - - self._dss.text("plot circuit Power max=2000 y n C1=$00FF0000") - - -class VTCDVunerabilityArea: - - def __init__(self, dss: DSS): - self._dss = dss - - - def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0.5, v_3=0.95): - self._bus_analyzed = bus_analyzed - self._v_1 = v_1 - self._v_2 = v_2 - self._v_3 = v_3 - self.dss_file = dss_file - - bus_names = list() - for bus in self._dss.circuit.buses_names: - self._dss.circuit.set_active_bus(bus) - if len(self._dss.bus.nodes) >= 3 and self._dss.bus.x: - bus_names.append(bus) - - bus_color_dict = dict() - for bus in bus_names: - - self._dss.text(f"Compile [{self.dss_file}]") - - self._dss.text("batchedit regcontrol..* enabled=No") - self._dss.text("batchedit load..* enabled=No") - self._dss.text(f"Buscoords Buscoords.dat") - self._dss.text(f"new fault.3_ph phases=3 bus1={bus}") - self._dss.text("solve") - - self._dss.circuit.set_active_bus(self._bus_analyzed) - - v_min = min(self._dss.bus.vmag_angle_pu[0:6:2]) - - if v_min < v_1: - bus_color_dict[bus] = "black" - elif v_min < v_2: - bus_color_dict[bus] = "red" - elif v_min < v_3: - bus_color_dict[bus] = "yellow" - else: - print(v_min) - bus_color_dict[bus] = "green" - - for bus_name, color in bus_color_dict.items(): - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") - diff --git a/src/py_dss_tools/results/VTCDSagSwell.py b/src/py_dss_tools/results/VTCDSagSwell.py index 68962e0..0c10661 100644 --- a/src/py_dss_tools/results/VTCDSagSwell.py +++ b/src/py_dss_tools/results/VTCDSagSwell.py @@ -31,7 +31,7 @@ def sag_swell_1phsc_df_pu(self, bus_fault, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() vmags_df['vmin'] = vmags_df.min(axis=1) #Cria uma coluna adicional e faz o mínimo das 3 anteriores. - vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1)#Cria uma coluna adicional e faz o máximo das 3 primeiras + vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1) #Cria uma coluna adicional e faz o máximo das 3 primeiras colors_sag = [] for v_min in vmags_df['vmin']: diff --git a/src/py_dss_tools/results/VTCDVulnerabilityArea.py b/src/py_dss_tools/results/VTCDVulnerabilityArea.py index de7faa5..4d928b0 100644 --- a/src/py_dss_tools/results/VTCDVulnerabilityArea.py +++ b/src/py_dss_tools/results/VTCDVulnerabilityArea.py @@ -24,15 +24,8 @@ def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0 self._v_3 = v_3 self.dss_file = dss_file -#### Não funciona bem para as barras monofásicas. Ver com o Paulo algo para melhorar ou fazer a exclusão das mono, icluir todas somente no sag swell. -#### Fiz um if else para radar curtos mono para barras mono, mas causa sobretensão em algumas barras, ver com o Paulo pois não faz sentido fazer uma função -#### só para sag 3ph e outra para mono, tavez colocar aqui os critérios???? Mas não sei quais. Ou deixar sem mesmo e avisar o usuário que são barras mono e -#### não se aplica este estudo para barras mono. - vmags_df, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() - # vmags_df['node4'] = None - # values = [] # Criei esse para melhorar a lentidão, mas deu na mesma com a lista. for bus in self._dss.circuit.buses_names: self._dss.text(f"Compile [{self.dss_file}]") @@ -45,7 +38,7 @@ def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0 self._dss.text(f"new fault.3_ph_{bus} phases=3 bus1={bus} bus2={bus}.4.4.4") self._dss.text("solve") vmags_df_temp, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() - vmags_df_temp = vmags_df_temp.iloc[:, :-1] # Descarta a última coluna. + vmags_df_temp = vmags_df_temp.iloc[:, :-1] #Descarta a última coluna. vmags_df.loc[bus] = vmags_df_temp.loc[self._bus_analyzed].values else: @@ -54,18 +47,7 @@ def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0 vmags_df_temp, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() vmags_df.loc[bus] = vmags_df_temp.loc[self._bus_analyzed].values - # vmags_df_temp, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() - - # values.append(vmags_df_temp.loc[self._bus_analyzed].values) # Criei esse para melhorar a lentidão, mas deu na mesma com a lista. - - # vmags_df.loc[bus] = vmags_df_temp.loc[self._bus_analyzed].values ### Essa linha funcionou. - - # vmags_df.iloc[:, :] = values # Criei esse para melhorar a lentidão, mas deu na mesma com a lista. - - # vmags_df = vmags_df.iloc[:, :-1] - vmags_df['vmin'] = vmags_df.min(axis=1) # Gera uma coluna no df com nome vmin e armazena o mínimo das 3 anteriores. - -###### Ficou lento o código, mas deu na mesma com a lista. + vmags_df['vmin'] = vmags_df.min(axis=1) #Gera uma coluna no df com nome vmin e armazena o mínimo das 3 anteriores. colors = [] for v_min in vmags_df['vmin']: diff --git a/src/py_dss_tools/studies/StudyVTCD.py b/src/py_dss_tools/studies/StudyVTCD.py index ca852bc..c08cf73 100644 --- a/src/py_dss_tools/studies/StudyVTCD.py +++ b/src/py_dss_tools/studies/StudyVTCD.py @@ -14,10 +14,9 @@ class StudyVTCD(StudyBase): def __post_init__(self): super().__post_init__() - self._results = VTCDresults(self._dss) # Object created by composition - self._view = ViewVTCDresults(self._dss, self._results) # não sei o motivo, mas é necessário haver o self._results - # self._view = ViewFaultResults(self._dss, self._results) - # self._settings = StudyTemporalSettings(_dss=self.dss) + self._results = VTCDresults(self._dss) + self._view = ViewVTCDresults(self._dss, self._results) + @property def results(self): return self._results @@ -25,8 +24,3 @@ def results(self): @property def view(self): return self._view - -#run area vulnerabilit -#run outra coisa?????? - -#incluir um run aqui, recebe bus name aqui. diff --git a/src/py_dss_tools/view/VTCDSagCircuit.py b/src/py_dss_tools/view/VTCDSagCircuit.py index b255a10..169d05d 100644 --- a/src/py_dss_tools/view/VTCDSagCircuit.py +++ b/src/py_dss_tools/view/VTCDSagCircuit.py @@ -10,9 +10,7 @@ class VTCDSagCircuit: - # def __init__(self, dss: DSS, results = None): def __init__(self, dss: DSS, results): - # def __init__(self, dss: DSS, results: VTCDresults): #Qualquer um dos 2 def acima dá certo. Troquei para results: VTCDSag e fiz o import do VTCDSag lá em cima. self._results = results self._dss = dss self.vmags_df = None @@ -23,14 +21,16 @@ def vtcd_sag_circuit(self): if self._results is None: raise ValueError("VTCDresults object not set. Call set_results method first.") - vmags_df_circuit = self._results.vmags_df # também dá certo sem o import e com o dito lá no init "results=None". + vmags_df_circuit = self._results.vmags_df if vmags_df_circuit.empty: raise ValueError("vmags_df is empty. Run sag_3phsc_df_pu method first.") - # for index, row in self._results.vmags_df.iterrows(): # Esse também dá certo !!! + bus_fault = self._results._bus_fault + self._dss.text(f"AddBusMarker Bus={bus_fault} code=7 color=red size=14") #Destaca a barra + for index, row in vmags_df_circuit.iterrows(): bus_name = index # Obtém o valor da primeira coluna (bus_name) color = row.iloc[-1] # Obtém o valor da última coluna (color) - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=7") + self._dss.text("plot circuit Power max=0 n y C1=$00FF0000 1ph=3") diff --git a/src/py_dss_tools/view/VTCDSagSwellCircuit.py b/src/py_dss_tools/view/VTCDSagSwellCircuit.py index b6d9f4c..95284f5 100644 --- a/src/py_dss_tools/view/VTCDSagSwellCircuit.py +++ b/src/py_dss_tools/view/VTCDSagSwellCircuit.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- # @Author : Raphael Maccari # @Email : raphaelmaccari@gmail.com -# @File : VTCDSagCircuit.py +# @File : VTCDSagSwellCircuit.py # @Software: PyCharm from py_dss_interface import DSS @@ -24,21 +24,27 @@ def vtcd_sag_swell_circuit(self): vmags_df_circuit = self._results.vmags_df + bus_fault = self._results._bus_fault + self._dss.text(f"AddBusMarker Bus={bus_fault} code=7 color=red size=14") + if vmags_df_circuit.empty: raise ValueError("vmags_df is empty. Run sag_swell_1phsc_df_pu method first.") for index, row in vmags_df_circuit.iterrows(): - bus_name = index # Obtém o valor da primeira coluna (bus_name) - color = row['colors_sag'] # Obtém o valor da coluna "colors_sag" - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + bus_name = index #Obtém o valor da primeira coluna (bus_name) + color = row['colors_sag'] #Obtém o valor da coluna "colors_sag" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=7") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000 1ph=3" ) time.sleep(1) self._dss.text(f"ClearBusMarkers") # Fiz isso não repetir as cores + bus_fault = self._results._bus_fault # Adicionei + self._dss.text(f"AddBusMarker Bus={bus_fault} code=7 color=red size=14") + for index, row in vmags_df_circuit.iterrows(): - bus_name = index # Obtém o valor da primeira coluna (bus_name) - color = row['colors_swell'] # Obtém o valor da coluna "colors_swell" - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + bus_name = index #Obtém o valor da primeira coluna (bus_name) + color = row['colors_swell'] #Obtém o valor da coluna "colors_swell" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=7") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000 1ph=3") diff --git a/src/py_dss_tools/view/VTCDVulnerabilityCircuit.py b/src/py_dss_tools/view/VTCDVulnerabilityCircuit.py index fb12d6b..fb2f95c 100644 --- a/src/py_dss_tools/view/VTCDVulnerabilityCircuit.py +++ b/src/py_dss_tools/view/VTCDVulnerabilityCircuit.py @@ -11,9 +11,7 @@ class VTCDVulnerabilityCircuit: - # def __init__(self, dss: DSS, results = None): def __init__(self, dss: DSS, results): - # def __init__(self, dss: DSS, results: VTCDresults): #Qualquer um dos 2 def acima dá certo. Troquei para results: VTCDSag e fiz o import do VTCDSag lá em cima. self._results = results self._dss = dss self.vmags_df = None @@ -24,41 +22,48 @@ def vtcd_vulnerability_circuit_sc3ph(self): if self._results is None: raise ValueError("VTCDresults object not set. Call set_results method first.") - vmags_df_circuit = self._results.vmags_df # também dá certo sem o import e com o dito lá no init "results=None". + vmags_df_circuit = self._results.vmags_df if vmags_df_circuit.empty: raise ValueError("vmags_df is empty. Run vulnerability_sag_map_sc3ph method first.") - # for index, row in self._results.vmags_df.iterrows(): # Esse também dá certo !!! + bus_analyzed = self._results._bus_analyzed + self._dss.text(f"AddBusMarker Bus={bus_analyzed} code=7 color=red size=14") + for index, row in vmags_df_circuit.iterrows(): - bus_name = index # Obtém o valor da primeira coluna (bus_name) - color = row.iloc[-1] # Obtém o valor da última coluna (color) - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + bus_name = index #Obtém o valor da primeira coluna (bus_name) + color = row.iloc[-1] #Obtém o valor da última coluna (color) + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=7") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000 1ph=3") def vtcd_vulnerability_circuit_sc1ph(self): if self._results is None: raise ValueError("VTCDresults object not set. Call set_results method first.") - vmags_df_circuit = self._results.vmags_df # também dá certo sem o import e com o dito lá no init "results=None". + vmags_df_circuit = self._results.vmags_df if vmags_df_circuit.empty: raise ValueError("vmags_df is empty. Run vulnerability_sag_map_sc1ph method first.") - # for index, row in self._results.vmags_df.iterrows(): # Esse também dá certo !!! + bus_analyzed = self._results._bus_analyzed # Adicionei + self._dss.text(f"AddBusMarker Bus={bus_analyzed} code=7 color=red size=14") + for index, row in vmags_df_circuit.iterrows(): - bus_name = index # Obtém o valor da primeira coluna (bus_name) - color = row['colors_sag'] # Obtém o valor da coluna "colors_sag" - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + bus_name = index #Obtém o valor da primeira coluna (bus_name) + color = row['colors_sag'] #Obtém o valor da coluna "colors_sag" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=7") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000 1ph=3") time.sleep(1) - self._dss.text(f"ClearBusMarkers") # Fiz isso não repetir as cores + self._dss.text(f"ClearBusMarkers") + + bus_analyzed = self._results._bus_analyzed + self._dss.text(f"AddBusMarker Bus={bus_analyzed} code=7 color=red size=14") for index, row in vmags_df_circuit.iterrows(): - bus_name = index # Obtém o valor da primeira coluna (bus_name) - color = row['colors_swell'] # Obtém o valor da coluna "colors_swell" - self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=10") - self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000") + bus_name = index #Obtém o valor da primeira coluna (bus_name) + color = row['colors_swell'] #Obtém o valor da coluna "colors_swell" + self._dss.text(f"AddBusMarker Bus={bus_name} code=7 color={color} size=7") + self._dss.text("plot circuit Power max=2000 n y C1=$00FF0000 1ph=3") From 2d45c5321657d880b6180e622d8d59290f3d95e8 Mon Sep 17 00:00:00 2001 From: raphamac Date: Mon, 2 Sep 2024 20:32:23 -0300 Subject: [PATCH 11/11] Colocado mais cores no SAG. --- examples/vtcd_study_exemple.py | 18 ++--- src/py_dss_tools/results/VTCDSag.py | 46 +++++++++++-- src/py_dss_tools/results/VTCDSagSwell.py | 35 ++++++++-- .../results/VTCDVulnerabilityArea.py | 66 +++++++++++++++---- 4 files changed, 134 insertions(+), 31 deletions(-) diff --git a/examples/vtcd_study_exemple.py b/examples/vtcd_study_exemple.py index 8011a42..7152185 100644 --- a/examples/vtcd_study_exemple.py +++ b/examples/vtcd_study_exemple.py @@ -19,15 +19,15 @@ study.dss.text("batchedit regcontrol..* enabled=No") study.dss.text("batchedit load..* enabled=No") -study.results.sag_3phsc_df_pu("95") -study.view.vtcd_sag_circuit() - -study.results.sag_swell_1phsc_df_pu("95") -study.view.vtcd_sag_swell_circuit() - -study.results.bus_vulnerability_sag_map_sc3ph("52", dss_file) -study.view.vtcd_vulnerability_circuit_sc3ph() - +# study.results.sag_3phsc_df_pu("95") +# study.view.vtcd_sag_circuit() + +# study.results.sag_swell_1phsc_df_pu("95") +# study.view.vtcd_sag_swell_circuit() +# +# study.results.bus_vulnerability_sag_map_sc3ph("52", dss_file) +# study.view.vtcd_vulnerability_circuit_sc3ph() +# study.results.bus_vulnerability_sag_swell_map_sc1ph("52", dss_file) study.view.vtcd_vulnerability_circuit_sc1ph() diff --git a/src/py_dss_tools/results/VTCDSag.py b/src/py_dss_tools/results/VTCDSag.py index 10cdac7..2299ef4 100644 --- a/src/py_dss_tools/results/VTCDSag.py +++ b/src/py_dss_tools/results/VTCDSag.py @@ -16,11 +16,18 @@ def __init__(self, dss: DSS): self._dss = dss self.vmags_df = pd.DataFrame() - def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95) -> pd.DataFrame: + def sag_3phsc_df_pu(self, bus_fault,v_1=0.1,v_2=0.2,v_3=0.3,v_4=0.4,v_5=0.5,v_6=0.6,v_7=0.7,v_8=0.8,v_9=0.9,v_10=0.95) -> pd.DataFrame: self._bus_fault = bus_fault self._v_1 = v_1 self._v_2 = v_2 self._v_3 = v_3 + self._v_4 = v_4 + self._v_5 = v_5 + self._v_6 = v_6 + self._v_7 = v_7 + self._v_8 = v_8 + self._v_9 = v_9 + self._v_10 = v_10 self._dss.text(f"new fault.3_ph_{self._bus_fault} phases=3 bus1={self._bus_fault} bus2={self._bus_fault}.4.4.4") self._dss.text("solve") vmags_df, vangs_df = DSSTools(self._dss).results.circuit_vmag_vang_dfs() @@ -29,12 +36,26 @@ def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95) -> pd.DataFrame: colors = [] for v_min in vmags_df['vmin']: - if v_min < v_1: + if v_min <= v_1: colors.append("black") - elif v_min < v_2: - colors.append("red") - elif v_min < v_3: + elif v_min <= v_2: + colors.append("maroon") + elif v_min <= v_3: + colors.append("purple") + elif v_min <= v_4: + colors.append("navy") + elif v_min <= v_5: + colors.append("teal") + elif v_min <= v_6: + colors.append("blue") + elif v_min <= v_7: + colors.append("aqua") + elif v_min <= v_8: colors.append("yellow") + elif v_min <= v_9: + colors.append("lime") + elif v_min < v_10: + colors.append("olive") else: colors.append("green") @@ -43,3 +64,18 @@ def sag_3phsc_df_pu(self, bus_fault,v_1=0.1, v_2=0.5, v_3=0.95) -> pd.DataFrame: self.vmags_df = vmags_df return vmags_df + + + + # sag_3phsc_df_pu(self, bus_fault, v_1=0.1, v_2=0.5, v_3=0.95) + + # colors = [] + # for v_min in vmags_df['vmin']: + # if v_min < v_1: + # colors.append("black") + # elif v_min < v_2: + # colors.append("red") + # elif v_min < v_3: + # colors.append("yellow") + # else: + # colors.append("green") diff --git a/src/py_dss_tools/results/VTCDSagSwell.py b/src/py_dss_tools/results/VTCDSagSwell.py index 0c10661..d35d2ed 100644 --- a/src/py_dss_tools/results/VTCDSagSwell.py +++ b/src/py_dss_tools/results/VTCDSagSwell.py @@ -16,12 +16,20 @@ def __init__(self, dss: DSS): self._dss = dss self.vmags_df = pd.DataFrame() - def sag_swell_1phsc_df_pu(self, bus_fault, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vswell_1=1.05, - vswell_2=1.06, vswell_3=1.1) -> pd.DataFrame: + def sag_swell_1phsc_df_pu(self, bus_fault,vsag_1=0.1,vsag_2=0.2,vsag_3=0.3,vsag_4=0.4,vsag_5=0.5,vsag_6=0.6,vsag_7=0.7, + vsag_8=0.8,vsag_9=0.9,vsag_10=0.95, vswell_1=1.05, vswell_2=1.06, vswell_3=1.1) -> pd.DataFrame: + self._bus_fault = bus_fault self._vsag_1 = vsag_1 self._vsag_2 = vsag_2 self._vsag_3 = vsag_3 + self._vsag_4 = vsag_4 + self._vsag_5 = vsag_5 + self._vsag_6 = vsag_6 + self._vsag_7 = vsag_7 + self._vsag_8 = vsag_8 + self._vsag_9 = vsag_9 + self._vsag_10 = vsag_10 self._vswell_1 = vswell_1 self._vswell_2 = vswell_2 self._vswell_3 = vswell_3 @@ -34,13 +42,28 @@ def sag_swell_1phsc_df_pu(self, bus_fault, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vmags_df['vmax'] = vmags_df.iloc[:, :-1].max(axis=1) #Cria uma coluna adicional e faz o máximo das 3 primeiras colors_sag = [] + for v_min in vmags_df['vmin']: - if v_min < vsag_1: + if v_min <= vsag_1: colors_sag.append("black") - elif v_min < vsag_2: - colors_sag.append("red") - elif v_min < vsag_3: + elif v_min <= vsag_2: + colors_sag.append("maroon") + elif v_min <= vsag_3: + colors_sag.append("purple") + elif v_min <= vsag_4: + colors_sag.append("navy") + elif v_min <= vsag_5: + colors_sag.append("teal") + elif v_min <= vsag_6: + colors_sag.append("blue") + elif v_min <= vsag_7: + colors_sag.append("aqua") + elif v_min <= vsag_8: colors_sag.append("yellow") + elif v_min <= vsag_9: + colors_sag.append("lime") + elif v_min < vsag_10: + colors_sag.append("olive") else: colors_sag.append("green") diff --git a/src/py_dss_tools/results/VTCDVulnerabilityArea.py b/src/py_dss_tools/results/VTCDVulnerabilityArea.py index 4d928b0..4a08034 100644 --- a/src/py_dss_tools/results/VTCDVulnerabilityArea.py +++ b/src/py_dss_tools/results/VTCDVulnerabilityArea.py @@ -17,11 +17,18 @@ def __init__(self, dss: DSS): self.vmags_df = pd.DataFrame() - def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0.5, v_3=0.95): + def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1,v_2=0.2,v_3=0.3,v_4=0.4,v_5=0.5,v_6=0.6,v_7=0.7,v_8=0.8,v_9=0.9,v_10=0.95): self._bus_analyzed = bus_analyzed self._v_1 = v_1 self._v_2 = v_2 self._v_3 = v_3 + self._v_4 = v_4 + self._v_5 = v_5 + self._v_6 = v_6 + self._v_7 = v_7 + self._v_8 = v_8 + self._v_9 = v_9 + self._v_10 = v_10 self.dss_file = dss_file vmags_df, _ = DSSTools(self._dss).results.circuit_vmag_vang_dfs() @@ -51,12 +58,26 @@ def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0 colors = [] for v_min in vmags_df['vmin']: - if v_min < v_1: + if v_min <= v_1: colors.append("black") - elif v_min < v_2: - colors.append("red") - elif v_min < v_3: + elif v_min <= v_2: + colors.append("maroon") + elif v_min <= v_3: + colors.append("purple") + elif v_min <= v_4: + colors.append("navy") # fuchsia + elif v_min <= v_5: + colors.append("teal") + elif v_min <= v_6: + colors.append("blue") + elif v_min <= v_7: + colors.append("aqua") + elif v_min <= v_8: colors.append("yellow") + elif v_min <= v_9: + colors.append("lime") + elif v_min < v_10: + colors.append("olive") else: colors.append("green") @@ -65,12 +86,21 @@ def bus_vulnerability_sag_map_sc3ph(self, bus_analyzed, dss_file, v_1=0.1, v_2=0 return vmags_df - def bus_vulnerability_sag_swell_map_sc1ph(self, bus_analyzed, dss_file, vsag_1=0.1, vsag_2=0.5, vsag_3=0.95, vswell_1=1.05, - vswell_2=1.06, vswell_3=1.1): + def bus_vulnerability_sag_swell_map_sc1ph(self, bus_analyzed, dss_file, vsag_1=0.1,vsag_2=0.2,vsag_3=0.3,vsag_4=0.4, + vsag_5=0.5,vsag_6=0.6,vsag_7=0.7,vsag_8=0.8,vsag_9=0.9,vsag_10=0.95, + vswell_1=1.05,vswell_2=1.06, vswell_3=1.1): + self._bus_analyzed = bus_analyzed self._vsag_1 = vsag_1 self._vsag_2 = vsag_2 self._vsag_3 = vsag_3 + self._vsag_4 = vsag_4 + self._vsag_5 = vsag_5 + self._vsag_6 = vsag_6 + self._vsag_7 = vsag_7 + self._vsag_8 = vsag_8 + self._vsag_9 = vsag_9 + self._vsag_10 = vsag_10 self._vswell_1 = vswell_1 self._vswell_2 = vswell_2 self._vswell_3 = vswell_3 @@ -95,12 +125,26 @@ def bus_vulnerability_sag_swell_map_sc1ph(self, bus_analyzed, dss_file, vsag_1=0 colors_sag = [] for v_min in vmags_df['vmin']: - if v_min < vsag_1: + if v_min <= vsag_1: colors_sag.append("black") - elif v_min < vsag_2: - colors_sag.append("red") - elif v_min < vsag_3: + elif v_min <= vsag_2: + colors_sag.append("maroon") + elif v_min <= vsag_3: + colors_sag.append("purple") + elif v_min <= vsag_4: + colors_sag.append("navy") + elif v_min <= vsag_5: + colors_sag.append("teal") + elif v_min <= vsag_6: + colors_sag.append("blue") + elif v_min <= vsag_7: + colors_sag.append("aqua") + elif v_min <= vsag_8: colors_sag.append("yellow") + elif v_min <= vsag_9: + colors_sag.append("lime") + elif v_min < vsag_10: + colors_sag.append("olive") else: colors_sag.append("green")