VeraGrid 5.6.2__tar.gz → 5.6.3__tar.gz

{veragrid-5.6.2 → veragrid-5.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGrid
-Version: 5.6.2
+Version: 5.6.3
 Summary: VeraGrid is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/VeraGrid
 Author: Santiago Peñate Vera et. Al.

{veragrid-5.6.2 → veragrid-5.6.3}/VeraGrid/Gui/Diagrams/SchematicWidget/diagram_bus_selection_dialogue.py

@@ -3,14 +3,13 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
-from typing import List, Union, Any, TYPE_CHECKING
-from PySide6 import QtCore, QtGui, QtWidgets
-from PySide6.QtWidgets import (QApplication, QDialog, QTableView, QVBoxLayout, QPushButton, QHBoxLayout,
-                               QLabel, QComboBox, QSpacerItem, QSizePolicy)
+from typing import List, TYPE_CHECKING
+from PySide6 import QtWidgets
+from PySide6.QtWidgets import (QVBoxLayout, QPushButton)
 
 from VeraGrid.Gui.Diagrams.SchematicWidget.schematic_widget import (SchematicWidget, make_diagram_from_buses,
                                                                     SchematicDiagram)
-from VeraGridEngine.Devices.Substation.substation import Substation
+from VeraGridEngine.Devices.Substation.substation import Substation, DeviceType
 from VeraGridEngine.Devices.Substation.bus import Bus
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 
@@ -38,7 +37,7 @@ class DiagramBusSelectorDialogue(QtWidgets.QDialog):
 
         self.layout = QVBoxLayout(self)
 
-        selected_buses = grid.get_buses_from_objects(elements=[substation])
+        selected_buses = grid.get_buses_from_objects(elements=[substation], dtype=DeviceType.SubstationDevice)
 
         if len(selected_buses):
             diagram = make_diagram_from_buses(circuit=grid,

{veragrid-5.6.2 → veragrid-5.6.3}/VeraGrid/Gui/Diagrams/SchematicWidget/schematic_widget.py

@@ -4735,7 +4735,7 @@ class SchematicWidget(BaseDiagramWidget):
         vl_wizard.setModal(True)
         vl_wizard.exec()  # waits until closed
 
-        if vl_wizard.closed_ok is not None:
+        if vl_wizard.closed_ok:
             (new_buses,
              conn_buses,
              associated_branches,

{veragrid-5.6.2 → veragrid-5.6.3}/VeraGrid/Gui/GridReduce/grid_reduce.py

@@ -10,15 +10,16 @@ import numpy as np
 from VeraGrid.Gui.GridReduce.grid_reduce_gui import Ui_ReduceDialog
 from VeraGrid.Gui.general_dialogues import LogsDialogue
 from VeraGrid.Gui.messages import yes_no_question, warning_msg
-from VeraGrid.Gui.gui_functions import get_list_model
+from VeraGrid.Gui.gui_functions import get_list_model, enums_to_model
 from VeraGrid.Session.session import SimulationSession
 from VeraGridEngine.Devices.Substation.bus import Bus
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 from VeraGridEngine.Topology.GridReduction.di_shi_grid_reduction import di_shi_reduction
-from VeraGridEngine.Topology.GridReduction.ptdf_grid_reduction import ptdf_reduction, ptdf_reduction_projected, ptdf_reduction_ree_bad, ptdf_reduction_ree_less_bad
+from VeraGridEngine.Topology.GridReduction.ptdf_grid_reduction import ptdf_reduction, ptdf_reduction_projected, \
+    ptdf_reduction_ree_bad, ptdf_reduction_ree_less_bad
 from VeraGridEngine.Topology.GridReduction.ward_equivalents import ward_standard_reduction
 from VeraGridEngine.basic_structures import Logger
-from VeraGridEngine.enumerations import GridReductionMethod
+from VeraGridEngine.enumerations import GridReductionMethod, BusReductionMethod
 
 
 class GridReduceDialogue(QtWidgets.QDialog):
@@ -44,12 +45,18 @@ class GridReduceDialogue(QtWidgets.QDialog):
 
         self.ui.listView.setModel(get_list_model(list(selected_buses_set)))
 
-        methods = [GridReductionMethod.PTDF,
-                   GridReductionMethod.PTDFProjected,
-                   GridReductionMethod.DiShi,
-                   GridReductionMethod.Ward]
-        self.methods_dict = {m.value: m for m in methods}
-        self.ui.methodComboBox.setModel(get_list_model([m.value for m in methods]))
+        self.methods_dict, methods_mdl = enums_to_model(
+            [GridReductionMethod.PTDF,
+             GridReductionMethod.PTDFProjected,
+             GridReductionMethod.DiShi,
+             GridReductionMethod.Ward]
+        )
+        self.ui.methodComboBox.setModel(methods_mdl)
+
+        self.bus_methods_dict, bus_methods_mdl = enums_to_model(
+            [BusReductionMethod.Reduce, BusReductionMethod.Keep]
+        )
+        self.ui.busModeComboBox.setModel(bus_methods_mdl)
 
         self._grid: MultiCircuit = grid
         self._session: SimulationSession = session
@@ -59,7 +66,7 @@ class GridReduceDialogue(QtWidgets.QDialog):
 
         self.ui.reduceButton.clicked.connect(self.reduce_grid)
 
-    def reduce_grid(self):
+    def reduce_grid(self) -> None:
         """
         The elements of the grid will be added with new idtags.
         This is useful in the case you want to compose a new grid from grids that are the same.
@@ -67,21 +74,39 @@ class GridReduceDialogue(QtWidgets.QDialog):
         """
         if len(self._selected_buses_set):
 
-            method: GridReductionMethod = self.methods_dict[self.ui.methodComboBox.currentText()]
+            reduction_method: GridReductionMethod = self.methods_dict[self.ui.methodComboBox.currentText()]
+            bus_mode: BusReductionMethod = self.bus_methods_dict[self.ui.busModeComboBox.currentText()]
+
+            if bus_mode == BusReductionMethod.Reduce:
+                text = f"This will delete the selected buses and reintroduce their influence."
+            else:
+                text = "This will keep the selected buses and delete all others, reintroducing their influence."
+
+            text += f"using the {reduction_method.value} equivalent. "
+            "This cannot be undone and it is dangerous if you don't know"
+            "what you are doing \nAre you sure?"
 
             ok = yes_no_question(
-                text="This will delete the selected buses and reintroduce their influence"
-                     "using the Ward equivalent. This cannot be undone and it is dangerous if you don't know"
-                     "what you are doing \nAre you sure?",
+                text=text,
                 title="Grid reduction?")
 
             if ok:
 
-                # convert the set of buses to bus indices
-                reduction_bus_indices = np.array([self._grid.buses.index(b) for b in self._selected_buses_set],
-                                                 dtype=int)
+                if bus_mode == BusReductionMethod.Reduce:
+                    # convert the set of buses to bus indices
+                    reduction_bus_indices = np.array([self._grid.buses.index(b)
+                                                      for b in self._selected_buses_set],
+                                                     dtype=int)
+
+                elif bus_mode == BusReductionMethod.Keep:
+                    # the the other buses that are not in the set
+                    reduction_bus_indices = np.array([i for i in range(self._grid.get_bus_number())
+                                                      if self._grid.buses[i] not in self._selected_buses_set],
+                                                     dtype=int)
+                else:
+                    raise NotImplementedError(f"BusReductionMethod not implemented: {bus_mode.value}")
 
-                if method == GridReductionMethod.DiShi:
+                if reduction_method == GridReductionMethod.DiShi:
 
                     # get the previous power flow
                     _, pf_res = self._session.power_flow
@@ -97,7 +122,7 @@ class GridReduceDialogue(QtWidgets.QDialog):
                         V0=pf_res.voltage
                     )
 
-                elif method == GridReductionMethod.Ward:
+                elif reduction_method == GridReductionMethod.Ward:
 
                     # get the previous power flow
                     _, pf_res = self._session.power_flow
@@ -113,7 +138,7 @@ class GridReduceDialogue(QtWidgets.QDialog):
                         V0=pf_res.voltage,
                     )
 
-                elif method == GridReductionMethod.PTDF:
+                elif reduction_method == GridReductionMethod.PTDF:
 
                     # NOTE: self._grid gets reduced in-place
                     grid_reduced, logger = ptdf_reduction(
@@ -121,16 +146,16 @@ class GridReduceDialogue(QtWidgets.QDialog):
                         reduction_bus_indices=reduction_bus_indices,
                     )
 
-                elif method == GridReductionMethod.PTDFProjected:
+                elif reduction_method == GridReductionMethod.PTDFProjected:
 
                     # NOTE: self._grid gets reduced in-place
-                    
+
                     # get the options from the linear analysis driver
                     lin_drv, _ = self._session.linear_power_flow
                     distribute_slack = True
                     if lin_drv is not None:
                         distribute_slack = lin_drv.options.distribute_slack
-                    
+
                     grid_reduced, logger = ptdf_reduction_projected(
                         grid=self._grid,
                         reduction_bus_indices=reduction_bus_indices,

{veragrid-5.6.2 → veragrid-5.6.3}/VeraGrid/Gui/GridReduce/grid_reduce_gui.py

@@ -48,6 +48,11 @@ class Ui_ReduceDialog(object):
         self.horizontalLayout = QHBoxLayout(self.frame)
         self.horizontalLayout.setObjectName(u"horizontalLayout")
         self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
+        self.busModeComboBox = QComboBox(self.frame)
+        self.busModeComboBox.setObjectName(u"busModeComboBox")
+
+        self.horizontalLayout.addWidget(self.busModeComboBox)
+
         self.methodComboBox = QComboBox(self.frame)
         self.methodComboBox.setObjectName(u"methodComboBox")
 
@@ -73,6 +78,8 @@ class Ui_ReduceDialog(object):
 
     def retranslateUi(self, ReduceDialog):
         ReduceDialog.setWindowTitle(QCoreApplication.translate("ReduceDialog", u"Grid Merge", None))
+        self.busModeComboBox.setPlaceholderText(QCoreApplication.translate("ReduceDialog", u"Buses", None))
+        self.methodComboBox.setPlaceholderText(QCoreApplication.translate("ReduceDialog", u"Method", None))
 #if QT_CONFIG(tooltip)
         self.reduceButton.setToolTip(QCoreApplication.translate("ReduceDialog", u"Aply the selected changes", None))
 #endif // QT_CONFIG(tooltip)

{veragrid-5.6.2 → veragrid-5.6.3}/VeraGrid/Gui/Main/SubClasses/Model/data_base.py

@@ -407,7 +407,7 @@ class DataBaseTableMain(DiagramsMain):
             source_model = proxy_model.sourceModel()
 
             sel_idx = self.ui.dataStructureTableView.selectedIndexes()
-            objects = source_model.objects if hasattr(source_model, 'objects') else []
+            objects: List[ALL_DEV_TYPES] = source_model.objects if hasattr(source_model, 'objects') else []
 
             if len(objects) > 0:
 
@@ -419,7 +419,8 @@ class DataBaseTableMain(DiagramsMain):
                         sel_obj: ALL_DEV_TYPES = source_model.objects[idx]
                         selected_objects.append(sel_obj)
 
-                    buses = self.circuit.get_buses_from_objects(elements=selected_objects)
+                    buses = self.circuit.get_buses_from_objects(elements=selected_objects,
+                                                                dtype=objects[0].device_type)
 
         return buses, selected_objects
 
@@ -699,8 +700,19 @@ class DataBaseTableMain(DiagramsMain):
             self.grid_reduction_dialogue.exec()
 
             if self.grid_reduction_dialogue.did_reduce:
+
+                # delete from the diagrams
                 self.delete_from_all_diagrams(elements=list(selected_buses))
 
+                # update the view
+                self.view_objects_data()
+                self.update_from_to_list_views()
+                self.update_date_dependent_combos()
+            else:
+                self.show_warning_toast("No reduction done")
+        else:
+            self.show_warning_toast("Select some elements first")
+
     def grid_reduction_from_schematic_selection(self):
         """
         Call the grid reduction dialogue on the schematic selection
@@ -1011,8 +1023,6 @@ class DataBaseTableMain(DiagramsMain):
                         #     # update event
                         #     self.circuit.rms_events[idx] = self.rms_events_Editor_window.get_updated_event()
 
-
-
                     else:
 
                         warning_msg('No editor available.\n'

{veragrid-5.6.2 → veragrid-5.6.3}/VeraGrid/Gui/Main/SubClasses/Model/diagrams.py

@@ -1964,7 +1964,8 @@ class DiagramsMain(CompiledArraysMain):
                      title="Substations schematic")
             return
 
-        selected_buses = self.circuit.get_buses_from_objects(elements=substations)
+        selected_buses = self.circuit.get_buses_from_objects(elements=substations,
+                                                             dtype=DeviceType.SubstationDevice)
 
         if len(selected_buses):
             diagram = make_diagram_from_buses(circuit=self.circuit,
@@ -2005,7 +2006,8 @@ class DiagramsMain(CompiledArraysMain):
             self.show_error_toast("The current diagram is not a schematic :(")
             return
 
-        selected_buses = self.circuit.get_buses_from_objects(elements=substations)
+        selected_buses = self.circuit.get_buses_from_objects(elements=substations,
+                                                             dtype=DeviceType.SubstationDevice)
 
         if len(selected_buses):
             diagram_widget.add_buses(selected_buses)

{veragrid-5.6.2 → veragrid-5.6.3}/VeraGrid/Gui/Main/SubClasses/simulations.py

@@ -60,39 +60,45 @@ class SimulationsMain(TimeEventsMain):
         self._remote_jobs: Dict[str, RemoteJobDriver] = dict()
 
         # Power Flow Methods
-        self.se_solvers_dict, se_solvers_mdl = gf.enums_to_model([SolverType.NR,
-                                                                  SolverType.LM,
-                                                                  SolverType.GN])
+        self.se_solvers_dict, se_solvers_mdl = gf.enums_to_model(
+            [SolverType.NR,
+             SolverType.LM,
+             SolverType.GN]
+        )
         self.ui.se_solver_comboBox.setModel(se_solvers_mdl)
         self.ui.se_solver_comboBox.setCurrentIndex(0)
 
         # SE Methods
-        self.solvers_dict, solvers_mdl = gf.enums_to_model([SolverType.NR,
-                                                            SolverType.IWAMOTO,
-                                                            SolverType.LM,
-                                                            SolverType.PowellDogLeg,
-                                                            SolverType.FASTDECOUPLED,
-                                                            SolverType.HELM,
-                                                            SolverType.GAUSS,
-                                                            SolverType.LACPF,
-                                                            SolverType.Linear])
+        self.solvers_dict, solvers_mdl = gf.enums_to_model(
+            [SolverType.NR,
+             SolverType.IWAMOTO,
+             SolverType.LM,
+             SolverType.PowellDogLeg,
+             SolverType.FASTDECOUPLED,
+             SolverType.HELM,
+             SolverType.GAUSS,
+             SolverType.LACPF,
+             SolverType.Linear]
+        )
         self.ui.solver_comboBox.setModel(solvers_mdl)
         self.ui.solver_comboBox.setCurrentIndex(0)
 
         # transfer modes
-        self.transfer_modes_dict = OrderedDict()
-        self.transfer_modes_dict['Area generation'] = AvailableTransferMode.Generation
-        self.transfer_modes_dict['Area installed power'] = AvailableTransferMode.InstalledPower
-        self.transfer_modes_dict['Area load'] = AvailableTransferMode.Load
-        self.transfer_modes_dict['Area nodes'] = AvailableTransferMode.GenerationAndLoad
-        lst = list(self.transfer_modes_dict.keys())
-        self.ui.transferMethodComboBox.setModel(gf.get_list_model(lst))
+        self.transfer_modes_dict, transfer_modes_mdl = gf.enums_to_model(
+            [AvailableTransferMode.Generation,
+             AvailableTransferMode.InstalledPower,
+             AvailableTransferMode.Load,
+             AvailableTransferMode.GenerationAndLoad]
+        )
+        self.ui.transferMethodComboBox.setModel(transfer_modes_mdl)
         self.ui.transferMethodComboBox.setCurrentIndex(1)
 
         # opf solvers dictionary
-        self.lp_solvers_dict, lp_solvers_mdl = gf.enums_to_model([SolverType.LINEAR_OPF,
-                                                                  SolverType.NONLINEAR_OPF,
-                                                                  SolverType.GREEDY_DISPATCH_OPF])
+        self.lp_solvers_dict, lp_solvers_mdl = gf.enums_to_model(
+            [SolverType.LINEAR_OPF,
+             SolverType.NONLINEAR_OPF,
+             SolverType.GREEDY_DISPATCH_OPF]
+        )
         self.ui.lpf_solver_comboBox.setModel(lp_solvers_mdl)
 
         # opf dispatch methods
@@ -104,43 +110,47 @@ class SimulationsMain(TimeEventsMain):
         )
         self.ui.opfDispatchModeComboBox.setModel(opf_dispatch_mode_mdl)
 
+        # MIP frameworks
         self.opf_mip_framework_dict, opf_mip_framework_mdl = gf.enums_to_model(
             get_available_mip_frameworks()
         )
         self.ui.mip_framework_comboBox.setModel(opf_mip_framework_mdl)
 
         # reliability modes
-        self.reliability_mode_dict = OrderedDict()
-        self.reliability_mode_dict[ReliabilityMode.GenerationAdequacy.value] = ReliabilityMode.GenerationAdequacy
-        self.reliability_mode_dict[ReliabilityMode.GridMetrics.value] = ReliabilityMode.GridMetrics
-        self.ui.reliability_method_comboBox.setModel(gf.get_list_model(list(self.reliability_mode_dict.keys())))
+        (self.reliability_mode_dict,
+         reliability_mode_dict_mdl) = gf.enums_to_model(
+            [ReliabilityMode.GenerationAdequacy,
+             ReliabilityMode.GridMetrics]
+        )
+        self.ui.reliability_method_comboBox.setModel(reliability_mode_dict_mdl)
 
         # ips solvers dictionary
-        self.ips_solvers_dict = OrderedDict()
-        self.ips_solvers_dict[SolverType.NR.value] = SolverType.NR
-        self.ui.ips_method_comboBox.setModel(gf.get_list_model(list(self.ips_solvers_dict.keys())))
+        (self.ips_solvers_dict,
+         ips_solvers_dict_mdl) = gf.enums_to_model(
+            [SolverType.NR]
+        )
+        self.ui.ips_method_comboBox.setModel(ips_solvers_dict_mdl)
 
         # the MIP combobox models assigning is done in modify_ui_options_according_to_the_engine
-        self.mip_solvers_dict = OrderedDict()
-        self.mip_solvers_dict[MIPSolvers.HIGHS.value] = MIPSolvers.HIGHS
-        self.mip_solvers_dict[MIPSolvers.SCIP.value] = MIPSolvers.SCIP
-        self.mip_solvers_dict[MIPSolvers.CPLEX.value] = MIPSolvers.CPLEX
-        self.mip_solvers_dict[MIPSolvers.GUROBI.value] = MIPSolvers.GUROBI
-        self.mip_solvers_dict[MIPSolvers.XPRESS.value] = MIPSolvers.XPRESS
-        self.mip_solvers_dict[MIPSolvers.CBC.value] = MIPSolvers.CBC
-        self.mip_solvers_dict[MIPSolvers.PDLP.value] = MIPSolvers.PDLP
+        (self.mip_solvers_dict,
+         mip_solvers_dict_mdl) = gf.enums_to_model(
+            [MIPSolvers.HIGHS,
+             MIPSolvers.SCIP,
+             MIPSolvers.CPLEX,
+             MIPSolvers.GUROBI,
+             MIPSolvers.XPRESS,
+             MIPSolvers.CBC,
+             MIPSolvers.PDLP]
+        )
 
         # opf solvers dictionary
-        self.nodal_capacity_methods_dict = OrderedDict()
-
-        for val in [NodalCapacityMethod.LinearOptimization,
-                    NodalCapacityMethod.NonlinearOptimization,
-                    NodalCapacityMethod.CPF]:
-            self.nodal_capacity_methods_dict[val.value] = val
-
-        self.ui.nodal_capacity_method_comboBox.setModel(
-            gf.get_list_model(list(self.nodal_capacity_methods_dict.keys()))
+        (self.nodal_capacity_methods_dict,
+         nodal_capacity_methods_mdl) = gf.enums_to_model(
+            [NodalCapacityMethod.LinearOptimization,
+             NodalCapacityMethod.NonlinearOptimization,
+             NodalCapacityMethod.CPF]
         )
+        self.ui.nodal_capacity_method_comboBox.setModel(nodal_capacity_methods_mdl)
 
         # branch types for reduction
         mdl = gf.get_list_model([DeviceType.LineDevice.value,
@@ -148,19 +158,23 @@ class SimulationsMain(TimeEventsMain):
         self.ui.removeByTypeListView.setModel(mdl)
 
         # OPF grouping modes
-        self.opf_time_groups = OrderedDict()
-        self.opf_time_groups[TimeGrouping.NoGrouping.value] = TimeGrouping.NoGrouping
-        self.opf_time_groups[TimeGrouping.Monthly.value] = TimeGrouping.Monthly
-        self.opf_time_groups[TimeGrouping.Weekly.value] = TimeGrouping.Weekly
-        self.opf_time_groups[TimeGrouping.Daily.value] = TimeGrouping.Daily
-        self.opf_time_groups[TimeGrouping.Hourly.value] = TimeGrouping.Hourly
-        self.ui.opf_time_grouping_comboBox.setModel(gf.get_list_model(list(self.opf_time_groups.keys())))
-
-        self.opf_zonal_groups = OrderedDict()
-        self.opf_zonal_groups[ZonalGrouping.NoGrouping.value] = ZonalGrouping.NoGrouping
-        # self.opf_zonal_groups[ZonalGrouping.Area.value] = ZonalGrouping.Area
-        self.opf_zonal_groups[ZonalGrouping.All.value] = ZonalGrouping.All
-        self.ui.opfZonalGroupByComboBox.setModel(gf.get_list_model(list(self.opf_zonal_groups.keys())))
+        (self.opf_time_groups,
+         opf_time_groups_mdl) = gf.enums_to_model(
+            [TimeGrouping.NoGrouping,
+             TimeGrouping.Monthly,
+             TimeGrouping.Weekly,
+             TimeGrouping.Daily,
+             TimeGrouping.Hourly]
+        )
+        self.ui.opf_time_grouping_comboBox.setModel(opf_time_groups_mdl)
+
+        # zonal opf grouping
+        (self.opf_zonal_groups,
+         opf_zonal_groups_mdl) = gf.enums_to_model(
+            [ZonalGrouping.NoGrouping,
+             ZonalGrouping.All]
+        )
+        self.ui.opfZonalGroupByComboBox.setModel(opf_zonal_groups_mdl)
 
         # voltage collapse mode (full, nose)
         self.ui.vc_stop_at_comboBox.setModel(gf.get_list_model([sim.CpfStopAt.Nose.value,
@@ -168,63 +182,56 @@ class SimulationsMain(TimeEventsMain):
         self.ui.vc_stop_at_comboBox.setCurrentIndex(0)
 
         # reactive power controls
-        self.contingency_engines_dict = OrderedDict()
-        self.contingency_engines_dict[ContingencyMethod.PowerFlow.value] = ContingencyMethod.PowerFlow
-        # self.contingency_engines_dict[ContingencyMethod.OptimalPowerFlow.value] = ContingencyMethod.OptimalPowerFlow
-        self.contingency_engines_dict[ContingencyMethod.Linear.value] = ContingencyMethod.Linear
-        self.contingency_engines_dict[ContingencyMethod.PTDF_scan.value] = ContingencyMethod.PTDF_scan
-        self.contingency_engines_dict[ContingencyMethod.HELM.value] = ContingencyMethod.HELM
-        self.ui.contingencyEngineComboBox.setModel(gf.get_list_model(list(self.contingency_engines_dict.keys())))
+        (self.contingency_engines_dict,
+         contingency_engines_mdl) = gf.enums_to_model(
+            [ContingencyMethod.PowerFlow,
+             ContingencyMethod.Linear,
+             ContingencyMethod.PTDF_scan,
+             ContingencyMethod.HELM]
+        )
+        self.ui.contingencyEngineComboBox.setModel(contingency_engines_mdl)
 
         # list of stochastic power flow methods
-        self.stochastic_pf_methods_dict = OrderedDict()
-        self.stochastic_pf_methods_dict[
-            sim.StochasticPowerFlowType.LatinHypercube.value] = sim.StochasticPowerFlowType.LatinHypercube
-        self.stochastic_pf_methods_dict[
-            sim.StochasticPowerFlowType.MonteCarlo.value] = sim.StochasticPowerFlowType.MonteCarlo
-        mdl = gf.get_list_model(list(self.stochastic_pf_methods_dict.keys()))
-        self.ui.stochastic_pf_method_comboBox.setModel(mdl)
+        (self.stochastic_pf_methods_dict,
+         stochastic_pf_methods_mdl) = gf.enums_to_model(
+            [sim.StochasticPowerFlowType.LatinHypercube,
+             sim.StochasticPowerFlowType.MonteCarlo]
+        )
+        self.ui.stochastic_pf_method_comboBox.setModel(stochastic_pf_methods_mdl)
 
         # investment evaluation methods
-        investment_methods = [
-            InvestmentEvaluationMethod.Independent,
-            InvestmentEvaluationMethod.NSGA3,
-            InvestmentEvaluationMethod.MVRSM,
-            InvestmentEvaluationMethod.MixedVariableGA,
-        ]
-        self.investment_evaluation_method_dict = OrderedDict()
-        self.plugins_investment_evaluation_method_dict = OrderedDict()
-        lst = list()
-        for method in investment_methods:
-            self.investment_evaluation_method_dict[method.value] = method
-            lst.append(method.value)
-        self.ui.investment_evaluation_method_ComboBox.setModel(gf.get_list_model(lst))
+        (self.investment_evaluation_method_dict,
+         investment_evaluation_method_mdl) = gf.enums_to_model(
+            [InvestmentEvaluationMethod.Independent,
+             InvestmentEvaluationMethod.NSGA3,
+             InvestmentEvaluationMethod.MVRSM,
+             InvestmentEvaluationMethod.MixedVariableGA, ]
+        )
+        self.ui.investment_evaluation_method_ComboBox.setModel(investment_evaluation_method_mdl)
 
         # contingency filtering modes
-        con_filters = [ContingencyFilteringMethods.AllActive,
-                       ContingencyFilteringMethods.Country,
-                       ContingencyFilteringMethods.Area,
-                       ContingencyFilteringMethods.Zone,
-                       ContingencyFilteringMethods.SensitiveToMonitored]
-        self.contingency_filter_modes_dict = OrderedDict()
-        con_filter_vals = list()
-        for con_filter in con_filters:
-            self.contingency_filter_modes_dict[con_filter.value] = con_filter
-            con_filter_vals.append(con_filter.value)
-        self.ui.contingency_filter_by_comboBox.setModel(gf.get_list_model(con_filter_vals))
-
-        # ptdf grouping modes
-        self.ptdf_group_modes = OrderedDict()
-
-        self.investment_evaluation_objfunc_dict = OrderedDict()
-        lst = list()
-        for method in [InvestmentsEvaluationObjectives.PowerFlow,
-                       InvestmentsEvaluationObjectives.TimeSeriesPowerFlow,
-                       InvestmentsEvaluationObjectives.GenerationAdequacy,
-                       InvestmentsEvaluationObjectives.SimpleDispatch]:
-            self.investment_evaluation_objfunc_dict[method.value] = method
-            lst.append(method.value)
-        self.ui.investment_evaluation_objfunc_ComboBox.setModel(gf.get_list_model(lst))
+        (self.contingency_filter_modes_dict,
+         contingency_filter_modes_mdl) = gf.enums_to_model(
+            [ContingencyFilteringMethods.AllActive,
+             ContingencyFilteringMethods.Country,
+             ContingencyFilteringMethods.Community,
+             ContingencyFilteringMethods.Region,
+             ContingencyFilteringMethods.Municipality,
+             ContingencyFilteringMethods.Area,
+             ContingencyFilteringMethods.Zone,
+             ContingencyFilteringMethods.SensitiveToMonitored]
+        )
+        self.ui.contingency_filter_by_comboBox.setModel(contingency_filter_modes_mdl)
+
+        # investment modes
+        (self.investment_evaluation_objfunc_dict,
+         investment_evaluation_objfunc_mdl) = gf.enums_to_model(
+            [InvestmentsEvaluationObjectives.PowerFlow,
+             InvestmentsEvaluationObjectives.TimeSeriesPowerFlow,
+             InvestmentsEvaluationObjectives.GenerationAdequacy,
+             InvestmentsEvaluationObjectives.SimpleDispatch]
+        )
+        self.ui.investment_evaluation_objfunc_ComboBox.setModel(investment_evaluation_objfunc_mdl)
 
         # dictionaries for available results
         self.available_results_dict: Union[Dict[str, Dict[str, ResultTypes]], None] = dict()
@@ -457,6 +464,21 @@ class SimulationsMain(TimeEventsMain):
                                     checks=True,
                                     check_value=True)
 
+        elif filter_mode == ContingencyFilteringMethods.Community:
+            mdl = gf.get_list_model(lst=[elm.name for elm in self.circuit.get_communities()],
+                                    checks=True,
+                                    check_value=True)
+
+        elif filter_mode == ContingencyFilteringMethods.Region:
+            mdl = gf.get_list_model(lst=[elm.name for elm in self.circuit.get_regions()],
+                                    checks=True,
+                                    check_value=True)
+
+        elif filter_mode == ContingencyFilteringMethods.Municipality:
+            mdl = gf.get_list_model(lst=[elm.name for elm in self.circuit.get_municipalities()],
+                                    checks=True,
+                                    check_value=True)
+
         elif filter_mode == ContingencyFilteringMethods.Area:
             mdl = gf.get_list_model(lst=[elm.name for elm in self.circuit.get_areas()],
                                     checks=True,
@@ -506,7 +528,40 @@ class SimulationsMain(TimeEventsMain):
                 return self.circuit.get_contingency_groups_in(grouping_elements=[elements[i] for i in idx])
             else:
                 # default to returning all groups, since it's safer
-                return self.circuit.get_contingency_groups()
+                return self.circuit.get_contingency_groups_active()
+
+        elif filter_mode == ContingencyFilteringMethods.Community:
+
+            if self.circuit.get_communities_number() > 0:
+                # get the selection indices
+                idx = gf.get_checked_indices(self.ui.contingency_group_filter_listView.model())
+                elements = self.circuit.get_communities()
+                return self.circuit.get_contingency_groups_in(grouping_elements=[elements[i] for i in idx])
+            else:
+                # default to returning all groups, since it's safer
+                return self.circuit.get_contingency_groups_active()
+
+        elif filter_mode == ContingencyFilteringMethods.Region:
+
+            if self.circuit.get_regions_number() > 0:
+                # get the selection indices
+                idx = gf.get_checked_indices(self.ui.contingency_group_filter_listView.model())
+                elements = self.circuit.get_regions()
+                return self.circuit.get_contingency_groups_in(grouping_elements=[elements[i] for i in idx])
+            else:
+                # default to returning all groups, since it's safer
+                return self.circuit.get_contingency_groups_active()
+
+        elif filter_mode == ContingencyFilteringMethods.Municipality:
+
+            if self.circuit.get_municipalities_number() > 0:
+                # get the selection indices
+                idx = gf.get_checked_indices(self.ui.contingency_group_filter_listView.model())
+                elements = self.circuit.get_municipalities()
+                return self.circuit.get_contingency_groups_in(grouping_elements=[elements[i] for i in idx])
+            else:
+                # default to returning all groups, since it's safer
+                return self.circuit.get_contingency_groups_active()
 
         elif filter_mode == ContingencyFilteringMethods.Area:
             if self.circuit.get_area_number() > 0:
@@ -516,7 +571,7 @@ class SimulationsMain(TimeEventsMain):
                 return self.circuit.get_contingency_groups_in(grouping_elements=[elements[i] for i in idx])
             else:
                 # default to returning all groups, since it's safer
-                return self.circuit.get_contingency_groups()
+                return self.circuit.get_contingency_groups_active()
 
         elif filter_mode == ContingencyFilteringMethods.Zone:
             if self.circuit.get_zone_number() > 0:
@@ -526,7 +581,7 @@ class SimulationsMain(TimeEventsMain):
                 return self.circuit.get_contingency_groups_in(grouping_elements=[elements[i] for i in idx])
             else:
                 # default to returning all groups, since it's safer
-                return self.circuit.get_contingency_groups()
+                return self.circuit.get_contingency_groups_active()
 
         elif filter_mode == ContingencyFilteringMethods.SensitiveToMonitored:
             idx = gf.get_checked_indices(self.ui.contingency_group_filter_listView.model())
@@ -1139,7 +1194,6 @@ class SimulationsMain(TimeEventsMain):
         if not self.session.is_anything_running():
             self.UNLOCK()
 
-
     def run_power_flow3ph(self):
         """
         Run a power flow simulation