GridCalEngine 5.1.6__tar.gz → 5.1.8__tar.gz

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/DataStructures/generator_data.py

@@ -306,3 +306,19 @@ class GeneratorData:
         :return:
         """
         return np.where(self.dispatchable == 1)[0]
+
+    def get_dispatchable_active_indices(self) -> IntVec:
+        """
+        Get the indices of dispatchable generators
+        :return:
+        """
+        x = (self.dispatchable * self.active).astype(int)
+        return np.where(x == 1)[0]
+
+    def get_non_dispatchable_indices(self) -> IntVec:
+        """
+        Get the indices of dispatchable generators
+        :return:
+        """
+        x = (~self.dispatchable * self.active).astype(int)
+        return np.where(x == 1)[0]

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Devices/Branches/hvdc_line.py

@@ -138,7 +138,7 @@ class HvdcLine(BranchParent):
 
     def __init__(self, bus_from: Bus = None, bus_to: Bus = None, name='HVDC Line', idtag=None, active=True, code='',
                  rate=1.0, Pset=0.0, r=1e-20, loss_factor=0.0, Vset_f=1.0, Vset_t=1.0, length=1.0, mttf=0.0, mttr=0.0,
-                 overload_cost=1000.0,   min_firing_angle_f=-1.0, max_firing_angle_f=1.0, min_firing_angle_t=-1.0,
+                 overload_cost=1000.0, min_firing_angle_f=-1.0, max_firing_angle_f=1.0, min_firing_angle_t=-1.0,
                  max_firing_angle_t=1.0, contingency_factor=1.0, protection_rating_factor: float = 1.4,
                  control_mode: HvdcControlType = HvdcControlType.type_1_Pset, dispatchable=True, angle_droop=0,
                  capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned, n_lines: int = 1):

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Devices/Diagrams/base_diagram.py

@@ -89,7 +89,7 @@ class PointsGroup:
         """
         Parse file data ito this class
         :param data: json dictionary
-        :param obj_dict: dicrtionary of relevant objects (idtag, object)
+        :param obj_dict: dictionary of relevant objects (idtag, object)
         :param logger: Logger
         :param category: category
         """
@@ -101,6 +101,7 @@ class PointsGroup:
 
             if api_object is None:
                 # locations with no API object are not created
+                print()
                 logger.add_error("Diagram location could not find API object",
                                  device_class=category,
                                  device=idtag,)

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/IO/cim/cgmes/cgmes_data_parser.py

@@ -356,18 +356,23 @@ class CgmesDataParser(BaseCircuit):
                     self.parsed_data[file_name] = file_cgmes_data
                     profile = model_info.get('profile', '')
 
-                    for prof in profile:
-                        if prof in cgmes2_4_15_uri:
-                            self.cgmes_version = "2.4.15"
-                        elif prof in cgmes3_0_0_uri:
-                            self.cgmes_version = "3.0.0"
-
                     if isinstance(profile, list):
+                        for prof in profile:
+                            if prof in cgmes2_4_15_uri:
+                                self.cgmes_version = "2.4.15"
+                            elif prof in cgmes3_0_0_uri:
+                                self.cgmes_version = "3.0.0"
+
                         if 'Boundary' in profile[0]:
                             merge(self.boudary_set, file_cgmes_data, self.logger)
                         else:
                             merge(self.data, file_cgmes_data, self.logger)
                     else:
+                        if profile in cgmes2_4_15_uri:
+                            self.cgmes_version = "2.4.15"
+                        elif profile in cgmes3_0_0_uri:
+                            self.cgmes_version = "3.0.0"
+
                         if 'Boundary' in profile:
                             merge(self.boudary_set, file_cgmes_data, self.logger)
                         else:

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/IO/cim/cgmes/gridcal_to_cgmes.py

@@ -460,7 +460,7 @@ def get_cgmes_cn_nodes(multi_circuit_model: MultiCircuit,
         else:
             logger.add_error(msg='Connectivity Node has no default bus',
                              device=mc_elm.name,
-                             device_class=gcdev.ConnectivityNode.type_name)
+                             device_class=mc_elm.device_type)
             # print(f'Topological node not found for cn: {cn.name}')
 
         cgmes_model.add(cn)

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/IO/file_handler.py

@@ -48,6 +48,8 @@ from GridCalEngine.IO.gridcal.h5_interface import save_h5, open_h5
 from GridCalEngine.IO.raw.rawx_parser_writer import parse_rawx, write_rawx
 from GridCalEngine.IO.others.pypsa_parser import parse_netcdf, parse_hdf5
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
+from GridCalEngine.Simulations.results_template import DriverToSave
+from GridCalEngine.enumerations import CGMESVersions
 
 
 class FileSavingOptions:
@@ -58,21 +60,25 @@ class FileSavingOptions:
     def __init__(self,
                  cgmes_boundary_set: str = "",
                  simulation_drivers: List[DriverTemplate] = None,
-                 sessions: List[Any] = None,
-                 dictionary_of_json_files: Dict[str, Dict[str, Any]] = None):
+                 sessions_data: List[DriverToSave] = None,
+                 dictionary_of_json_files: Dict[str, Dict[str, Any]] = None,
+                 cgmes_version: CGMESVersions = CGMESVersions.v2_4_15):
         """
         Constructor
         :param cgmes_boundary_set: CGMES boundary set zip file path
         :param simulation_drivers: List of Simulation Drivers
-        :param sessions: List of sessions
+        :param sessions_data: List of sessions_data
         :param dictionary_of_json_files: Dictionary of json files
+        :param cgmes_version: Version to use with CGMES
         """
 
+        self.cgmes_vesrion: CGMESVersions = cgmes_version
+
         self.cgmes_boundary_set: str = cgmes_boundary_set
 
         self.simulation_drivers = simulation_drivers if simulation_drivers else list()
 
-        self.sessions = sessions if sessions else list()
+        self.sessions_data: List[DriverToSave] = sessions_data if sessions_data else list()
 
         self.dictionary_of_json_files = dictionary_of_json_files if dictionary_of_json_files else dict()
 
@@ -398,7 +404,7 @@ class FileSave:
         save_gridcal_data_to_zip(dfs=dfs,
                                  filename_zip=self.file_name,
                                  model_data=model_data,
-                                 sessions=self.options.sessions,
+                                 sessions_data=self.options.sessions_data,
                                  diagrams=self.circuit.diagrams,
                                  json_files=self.options.dictionary_of_json_files,
                                  text_func=self.text_func,

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/IO/gridcal/zip_interface.py

@@ -22,16 +22,17 @@ import chardet
 import pandas as pd
 import zipfile
 from warnings import warn
-from typing import List, Dict, Any, Union, Callable
+from typing import List, Dict, Union, Callable
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.IO.gridcal.generic_io_functions import parse_config_df, CustomJSONizer
+from GridCalEngine.Simulations.results_template import DriverToSave
 import GridCalEngine.Devices as dev
 
 
 def save_gridcal_data_to_zip(dfs: Dict[str, pd.DataFrame],
                              filename_zip: str,
                              model_data: Dict[str, Dict[str, str]],
-                             sessions: List[Any],
+                             sessions_data: List[DriverToSave],
                              diagrams: List[Union[dev.MapDiagram, dev.SchematicDiagram]],
                              json_files: Dict[str, dict],
                              text_func: Union[None, Callable[[str], None]] = None,
@@ -42,7 +43,7 @@ def save_gridcal_data_to_zip(dfs: Dict[str, pd.DataFrame],
     :param dfs: dictionary of pandas dataFrames {name: DataFrame}
     :param filename_zip: file name where to save all
     :param model_data: dictionary of json data opposed to the dataframes collection
-    :param sessions: SimulationSession instance
+    :param sessions_data: List of DriverToSave instances, representing the results drivers data
     :param diagrams: List of Diagram objects
     :param json_files: List of configuration json files to save Dict[file_name, dictionary to save]
     :param text_func: pointer to function that prints the names
@@ -66,7 +67,7 @@ def save_gridcal_data_to_zip(dfs: Dict[str, pd.DataFrame],
             try:
                 f_zip_ptr.writestr(filename, json.dumps(object_data, indent=4, cls=CustomJSONizer))
             except TypeError as e:
-                logger.add_error(msg=e, device_class=object_type_name)
+                logger.add_error(msg=str(e), device_class=object_type_name)
                 warn(f"{object_type_name}: {e}")
 
         # save diagrams
@@ -115,42 +116,62 @@ def save_gridcal_data_to_zip(dfs: Dict[str, pd.DataFrame],
             i += 1
 
         # pre-count the sessions
-        n_items = 0
-        for session in sessions:
-            for drv_name, drv in session.drivers.items():
-                if hasattr(drv, 'results'):
-                    if drv.results is not None:
-                        for arr_name, arr in drv.results.get_arrays().items():
-                            n_items += 1
+        n_items = len(sessions_data)
 
         # save sessions
         i = 0
-        for session in sessions:
-            for drv_name, drv in session.drivers.items():
-                if hasattr(drv, 'results'):
-                    if drv.results is not None:
-                        for arr_name, arr in drv.results.get_arrays().items():
-                            filename = 'sessions/' + session.name + '/' + drv.tpe.value + '/' + arr_name
+        for session_data in sessions_data:
 
-                            if text_func is not None:
-                                text_func('Flushing ' + filename + ' to ' + filename_zip + '...')
+            if session_data.results is not None:
 
-                            with BytesIO() as buffer:
-                                # save the DataFrame to the buffer, protocol4 is to be compatible with python 3.6
-                                np.save(buffer, np.array(arr))  # save the DataFrame to the buffer
-                                f_zip_ptr.writestr(filename + '.npy',
-                                                   buffer.getvalue())  # save the buffer to the zip file
+                # traverse the registered results
+                for arr_name, arr_prop in session_data.results.data_variables.items():
 
-                            if progress_func is not None:
-                                progress_func((i + 1) / n_items * 100)
+                    filename = 'sessions/' + session_data.name + '/' + session_data.tpe.value + '/' + arr_name
 
-                            i += 1
+                    if text_func is not None:
+                        text_func('Flushing ' + filename + ' to ' + filename_zip + '...')
+
+                    # get the array
+                    arr = getattr(session_data.results, arr_name)
+
+                    with BytesIO() as buffer:
+                        # pack the array into a DataFrame
+
+                        try:
+                            if np.iscomplexobj(arr):
+                                filename += "__complex__"
+                                pd.DataFrame(data=np.c_[arr.real, arr.imag]).to_parquet(buffer)
+                            else:
+                                pd.DataFrame(data=arr).to_parquet(buffer)
+
+                            # save the buffer to the zip file
+                            f_zip_ptr.writestr(filename + ".parquet", buffer.getvalue())
+
+                        except ValueError as e:
+                            warn(str(e))
+
+                    if progress_func is not None:
+                        progress_func((i + 1) / n_items * 100)
+
+                    i += 1
+
+            # save logger
+            if session_data.logger is not None:
+                filename = 'sessions/' + session_data.name + '/' + session_data.tpe.value + '/logger.parquet'
+                with BytesIO() as buffer:
+                    # save the DataFrame to the buffer, protocol4 is to be compatible with python 3.6
+                    session_data.logger.to_df().to_parquet(buffer)
+                    # save the buffer to the zip file
+                    f_zip_ptr.writestr(filename, buffer.getvalue())
 
     if n_failed:
         print('Failed to pickle several profiles, but saved them as csv.\nFor improved speed install Pandas >= 1.2')
 
 
-def read_data_frame_from_zip(file_pointer, extension: str, index_col=None, logger=Logger()):
+def read_data_frame_from_zip(file_pointer,
+                             extension: str,
+                             index_col=None, logger=Logger()) -> Union[None, pd.DataFrame]:
     """
     read DataFrame
     :param file_pointer: Pointer to the file within the zip file
@@ -189,6 +210,26 @@ def read_data_frame_from_zip(file_pointer, extension: str, index_col=None, logge
                 logger.add_error(str(e) + ' Upgrading pandas might help.', device=file_pointer.name)
                 return None
 
+        elif extension == '.feather':
+            try:
+                return pd.read_feather(file_pointer)
+            except ValueError as e:
+                logger.add_error(str(e), device=file_pointer.name)
+                return None
+            except AttributeError as e:
+                logger.add_error(str(e) + ' Upgrading pandas might help.', device=file_pointer.name)
+                return None
+
+        elif extension == '.hdf':
+            try:
+                return pd.read_hdf(file_pointer, key='array')
+            except ValueError as e:
+                logger.add_error(str(e), device=file_pointer.name)
+                return None
+            except AttributeError as e:
+                logger.add_error(str(e) + ' Upgrading pandas might help.', device=file_pointer.name)
+                return None
+
     except EOFError:
         logger.add_error("EOF error", device=file_pointer.name)
         return None
@@ -209,19 +250,19 @@ def get_frames_from_zip(file_name_zip: str,
     :param logger:
     :return: list of DataFrames
     """
+    data = {'diagrams': list(),
+            'model_data': dict()}
+    json_files = dict()
 
     # open the zip file
     try:
         zip_file_pointer = zipfile.ZipFile(file_name_zip)
     except zipfile.BadZipFile:
-        return None
+        return data, json_files
 
     names = zip_file_pointer.namelist()
 
     n = len(names)
-    data = {'diagrams': list(),
-            'model_data': dict()}
-    json_files = dict()
 
     # for each file in the zip file...
     for i, file_name in enumerate(names):
@@ -329,13 +370,15 @@ def get_session_tree(file_name_zip: str):
     return data
 
 
-def load_session_driver_objects(file_name_zip: str, session_name: str, study_name: str):
+def load_session_driver_objects(file_name_zip: str,
+                                session_name: str,
+                                study_name: str) -> Dict[str, Union[None, pd.DataFrame]]:
     """
     Get the sessions structure
     :param file_name_zip:
     :param session_name:
     :param study_name:
-    :return:
+    :return: Dict[str, Union[None, pd.DataFrame]]
     """
     try:
         zip_file_pointer = zipfile.ZipFile(file_name_zip)
@@ -344,7 +387,7 @@ def load_session_driver_objects(file_name_zip: str, session_name: str, study_nam
 
     data = dict()
 
-    # traverse the zip names and pick all those that start with sessions/session_name/study_name
+    # traverse the zip names and pick all those that start with sessions_data/session_name/study_name
     for name in zip_file_pointer.namelist():
         if '/' in name:
             path = name.split('/')
@@ -360,15 +403,10 @@ def load_session_driver_objects(file_name_zip: str, session_name: str, study_nam
                     # read the data
                     data[arr_name] = read_data_frame_from_zip(file_pointer, extension)
 
-                    # try:
-                    #     data[arr_name] = np.load(file_pointer)
-                    # except ValueError:
-                    #     data[arr_name] = np.load(file_pointer, allow_pickle=True)
-
     return data
 
 
-def get_xml_content(file_ptr):
+def get_xml_content(file_ptr: zipfile.ZipExtFile) -> List[str]:
     """
     Reads the content of a file
     :param file_ptr: File pointer (from file or zip file)
@@ -383,7 +421,7 @@ def get_xml_content(file_ptr):
         try:
             detection = chardet.detect(first_line)
             encoding = detection['encoding']
-        except:
+        except TypeError:
             encoding = 'utf-8'
 
     # sequential back to the start
@@ -398,7 +436,7 @@ def get_xml_content(file_ptr):
 
 def get_xml_from_zip(file_name_zip: str,
                      text_func: Union[None, Callable[[str], None]] = None,
-                     progress_func: Union[None, Callable[[float], None]] = None,):
+                     progress_func: Union[None, Callable[[float], None]] = None, ):
     """
     Get the .xml files from a zip file
     :param file_name_zip: name of the zip file

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/ATC/available_transfer_capacity_ts_driver.py

@@ -200,17 +200,18 @@ class AvailableTransferCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
     tpe = SimulationTypes.NetTransferCapacityTS_run
     name = tpe.value
 
-    def __init__(
-            self, grid: MultiCircuit,
-            options: AvailableTransferCapacityOptions,
-            time_indices: np.ndarray,
-            clustering_results: Union[ClusteringResults, None] = None):
+    def __init__(self,
+                 grid: MultiCircuit,
+                 options: AvailableTransferCapacityOptions,
+                 time_indices: np.ndarray,
+                 clustering_results: Union[ClusteringResults, None] = None):
 
         """
         Power Transfer Distribution Factors class constructor
         :param grid: MultiCircuit Object
         :param options: OPF options
         :param time_indices: array of time indices to simulate
+        :param clustering_results: ClusteringResults (optional)
         """
 
         TimeSeriesDriverTemplate.__init__(

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/Clustering/clustering_driver.py

@@ -15,6 +15,7 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
+import numpy as np
 from typing import Union
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
 from GridCalEngine.Simulations.driver_types import SimulationTypes
@@ -38,7 +39,10 @@ class ClusteringDriver(DriverTemplate):
 
         self.options: ClusteringAnalysisOptions = options
 
-        self.results: Union[ClusteringResults, None] = None
+        self.results: Union[ClusteringResults, None] = ClusteringResults(time_indices=np.empty(0, dtype=int),
+                                                                         sampled_probabilities=np.empty(0),
+                                                                         time_array=np.empty(0),
+                                                                         original_sample_idx=np.empty(0, dtype=int))
 
     def run(self):
         """

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/ContingencyAnalysis/Methods/optimal_linear_contingency_analysis.py

@@ -118,6 +118,7 @@ def optimal_linear_contingency_analysis(grid: MultiCircuit,
                                  areas_from=list(),
                                  areas_to=list(),
                                  energy_0=None,
+                                 fluid_level_0=None,
                                  logger=logger,
                                  export_model_fname=None)
 

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/ContingencyAnalysis/__init__.py

@@ -17,6 +17,6 @@
 from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
 from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_driver import ContingencyAnalysisDriver
 from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
-from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_ts_driver import ContingencyAnalysisTimeSeries
+from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_ts_driver import ContingencyAnalysisTimeSeriesDriver
 from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_ts_results import ContingencyAnalysisTimeSeriesResults
 

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/ContingencyAnalysis/contingencies_report.py

@@ -258,7 +258,7 @@ class ContingencyResultsReport:
         """
         Add report data
         :param time_index:
-        :param t_prob_
+        :param t_prob:
         :param area_from:
         :param area_to:
         :param base_name:

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/ContingencyAnalysis/contingency_analysis_ts_driver.py

@@ -35,7 +35,7 @@ from GridCalEngine.Compilers.circuit_to_newton_pa import newton_pa_contingencies
 from GridCalEngine.Utils.NumericalMethods.weldorf_online_stddev import WeldorfOnlineStdDevMat
 
 
-class ContingencyAnalysisTimeSeries(TimeSeriesDriverTemplate):
+class ContingencyAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
     """
     Contingency Analysis Time Series
     """

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/ContinuationPowerFlow/continuation_power_flow_driver.py

@@ -30,21 +30,21 @@ class ContinuationPowerFlowDriver(DriverTemplate):
     name = 'Continuation Power Flow'
     tpe = SimulationTypes.ContinuationPowerFlow_run
 
-    def __init__(self, circuit: MultiCircuit,
+    def __init__(self, grid: MultiCircuit,
                  options: ContinuationPowerFlowOptions,
                  inputs: ContinuationPowerFlowInput,
                  pf_options: PowerFlowOptions,
                  opf_results=None, t=0):
         """
         ContinuationPowerFlowDriver constructor
-        :param circuit: NumericalCircuit instance
+        :param grid: NumericalCircuit instance
         :param options: ContinuationPowerFlowOptions instance
         :param inputs: ContinuationPowerFlowInput instance
         :param pf_options: PowerFlowOptions instance
         :param opf_results:
         """
 
-        DriverTemplate.__init__(self, grid=circuit)
+        DriverTemplate.__init__(self, grid=grid)
 
         # voltage stability options
         self.options = options
@@ -57,7 +57,12 @@ class ContinuationPowerFlowDriver(DriverTemplate):
 
         self.t = t
 
-        self.results = None
+        self.results = ContinuationPowerFlowResults(nval=0,
+                                                    nbus=0,
+                                                    nbr=0,
+                                                    bus_names=[],
+                                                    branch_names=[],
+                                                    bus_types=[])
 
     def get_steps(self):
         """
@@ -68,7 +73,7 @@ class ContinuationPowerFlowDriver(DriverTemplate):
         else:
             return list()
 
-    def progress_callback(self, lmbda):
+    def progress_callback(self, lmbda: float) -> None:
         """
         Send progress report
         :param lmbda: lambda value

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/LinearFactors/linear_analysis_driver.py

@@ -56,7 +56,11 @@ class LinearAnalysisDriver(DriverTemplate):
         self.opf_results = opf_results
 
         # Results
-        self.results: Union[LinearAnalysisResults, None] = None
+        self.results: Union[LinearAnalysisResults, None] = LinearAnalysisResults(n_br=0,
+                                                                                 n_bus=0,
+                                                                                 br_names=(),
+                                                                                 bus_names=(),
+                                                                                 bus_types=())
 
         self.all_solved: bool = True
 

{GridCalEngine-5.1.6 → GridCalEngine-5.1.8}/GridCalEngine/Simulations/OPF/NumericalMethods/ac_opf.py

@@ -501,10 +501,10 @@ def ac_optimal_power_flow(nc: NumericalCircuit,
 
     # Check the active elements and their operational limits.
     br_mon_idx = nc.branch_data.get_monitor_enabled_indices()
-    gen_disp_idx = nc.generator_data.get_dispatchable_indices()
+    gen_disp_idx = nc.generator_data.get_dispatchable_active_indices()
     ind_gens = np.arange(len(Pg_max))
-    nig = np.where(~np.isin(ind_gens, gen_disp_idx))[0]
-    Sg_undis = (nc.generator_data.get_injections() / nc.Sbase)[nig]
+    gen_nondisp_idx = nc.generator_data.get_non_dispatchable_indices()
+    Sg_undis = (nc.generator_data.get_injections() / nc.Sbase)[gen_nondisp_idx]
     rates = nc.rates / Sbase  # Line loading limits. If the grid is not well conditioned, add constant value (i.e. +100)
     Va_max = nc.bus_data.angle_max  # This limits are not really used as of right now.
     Va_min = nc.bus_data.angle_min
@@ -555,8 +555,8 @@ def ac_optimal_power_flow(nc: NumericalCircuit,
     if opf_options.acopf_mode == AcOpfMode.ACOPFslacks:
         nsl = 2 * npq + 2 * n_br_mon
         # Slack relaxations for constraints
-        c_s = 1 * np.power(nc.branch_data.overload_cost[br_mon_idx] + 1e-9, 1.0)  # Cost squared since the slack is also squared
-        c_v = 1 * nc.bus_data.cost_v[pq] + 1e-9
+        c_s = 1 * np.power(nc.branch_data.overload_cost[br_mon_idx] + 0.1, 1.0)  # Cost squared since the slack is also squared
+        c_v = 1 * (nc.bus_data.cost_v[pq] + 0.1)
         sl_sf0 = np.ones(n_br_mon)
         sl_st0 = np.ones(n_br_mon)
         sl_vmax0 = np.ones(npq)
@@ -629,7 +629,7 @@ def ac_optimal_power_flow(nc: NumericalCircuit,
                                        arg=(admittances, Cg, Sd, slack, from_idx, to_idx,
                                             pq, pv, Va_max, Va_min, Vm_max, Vm_min, Pg_max, Pg_min,
                                             Qg_max, Qg_min, tapm_max, tapm_min, tapt_max, tapt_min, alltapm, alltapt,
-                                            k_m, k_tau, k_mtau, c0, c1, c2, Sbase, rates, br_mon_idx, gen_disp_idx, nig,
+                                            k_m, k_tau, k_mtau, c0, c1, c2, Sbase, rates, br_mon_idx, gen_disp_idx, gen_nondisp_idx,
                                             Sg_undis, pf_options.control_Q, opf_options.acopf_mode),
                                        verbose=opf_options.verbose,
                                        max_iter=opf_options.ips_iterations,
@@ -644,7 +644,7 @@ def ac_optimal_power_flow(nc: NumericalCircuit,
                                            arg=(admittances, Cg, Sd, slack, from_idx, to_idx, pq, pv,
                                                 Va_max, Va_min, Vm_max, Vm_min, Pg_max, Pg_min, Qg_max, Qg_min,
                                                 tapm_max, tapm_min, tapt_max, tapt_min, k_m, k_tau, k_mtau,
-                                                c0, c1, c2, Sbase, rates, br_mon_idx, gen_disp_idx, nig, Sg_undis,
+                                                c0, c1, c2, Sbase, rates, br_mon_idx, gen_disp_idx, gen_nondisp_idx, Sg_undis,
                                                 opf_options.acopf_mode, 1e-5),
                                            verbose=opf_options.verbose,
                                            max_iter=opf_options.ips_iterations,
@@ -658,7 +658,7 @@ def ac_optimal_power_flow(nc: NumericalCircuit,
                                                 f_disp_hvdc, t_disp_hvdc, n_disp_hvdc, pq, pv, Pf_nondisp, P_hvdc_max, Vm_max, Vm_min, Pg_max,
                                                 Pg_min, tanmax, Qg_max, Qg_min, tapm_max, tapm_min, tapt_max, tapt_min,
                                                 alltapm, alltapt, k_m, k_tau, c0, c1, c2, c_s, c_v, Sbase, rates, br_mon_idx,
-                                                n_br_mon, gen_disp_idx, nig, Sg_undis, pf_options.control_Q, opf_options.acopf_mode),
+                                                n_br_mon, gen_disp_idx, gen_nondisp_idx, Sg_undis, pf_options.control_Q, opf_options.acopf_mode),
                                            verbose=opf_options.verbose,
                                            max_iter=opf_options.ips_iterations,
                                            tol=opf_options.ips_tolerance,
@@ -671,18 +671,18 @@ def ac_optimal_power_flow(nc: NumericalCircuit,
                                                  acopf_mode=opf_options.acopf_mode)
 
     # Save Results DataFrame for tests
-    # pd.DataFrame(Va).transpose().to_csv('pegase89resth.csv')
-    # pd.DataFrame(Vm).transpose().to_csv('pegase89resV.csv')
-    # pd.DataFrame(Pg_dis).transpose().to_csv('pegase89resP.csv')
-    # pd.DataFrame(Qg_dis).transpose().to_csv('pegase89resQ.csv')
+    #pd.DataFrame(Va).transpose().to_csv('REEresth.csv')
+    #pd.DataFrame(Vm).transpose().to_csv('REEresV.csv')
+    #pd.DataFrame(Pg_dis).transpose().to_csv('REEresP.csv')
+    #pd.DataFrame(Qg_dis).transpose().to_csv('REEresQ.csv')
 
     Pg = np.zeros(len(ind_gens))
     Qg = np.zeros(len(ind_gens))
 
     Pg[gen_disp_idx] = Pg_dis
     Qg[gen_disp_idx] = Qg_dis
-    Pg[nig] = np.real(Sg_undis)
-    Qg[nig] = np.imag(Sg_undis)
+    Pg[gen_nondisp_idx] = np.real(Sg_undis)
+    Qg[gen_nondisp_idx] = np.imag(Sg_undis)
 
     # convert the lagrange multipliers to significant ones
     lam_p, lam_q = result.lam[:nbus], result.lam[nbus:2 * nbus]