pandapower 2.14.2__zip → 2.14.6__zip

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/generators/asynchronousMachinesCim16.py

@@ -48,11 +48,11 @@ class AsynchronousMachinesCim16:
         eq_generating_units = pd.concat([eq_generating_units, self.cimConverter.cim['eq']['NuclearGeneratingUnit']],
                                         sort=False)
         eq_generating_units['type'].fillna('Nuclear', inplace=True)
-        eq_generating_units.rename(columns={'rdfId': 'GeneratingUnit'}, inplace=True)
+        eq_generating_units = eq_generating_units.rename(columns={'rdfId': 'GeneratingUnit'})
         eqssh_asynchronous_machines = self.cimConverter.merge_eq_ssh_profile('AsynchronousMachine',
                                                                              add_cim_type_column=True)
         # prevent conflict of merging two dataframes each containing column 'name'
-        eq_generating_units.drop('name', axis=1, inplace=True)
+        eq_generating_units = eq_generating_units.drop('name', axis=1)
         eqssh_asynchronous_machines = pd.merge(eqssh_asynchronous_machines, eq_generating_units,
                                                how='left', on='GeneratingUnit')
         eqssh_asynchronous_machines = pd.merge(eqssh_asynchronous_machines, self.cimConverter.bus_merge, how='left',
@@ -66,12 +66,12 @@ class AsynchronousMachinesCim16:
         eqssh_asynchronous_machines['generator_type'] = 'async'
         eqssh_asynchronous_machines['loading_percent'] = \
             100 * eqssh_asynchronous_machines['p_mw'] / eqssh_asynchronous_machines['ratedMechanicalPower']
-        eqssh_asynchronous_machines.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'],
+        eqssh_asynchronous_machines = eqssh_asynchronous_machines.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'],
                                                     'connected': 'in_service', 'index_bus': 'bus',
                                                     'rxLockedRotorRatio': 'rx', 'iaIrRatio': 'lrc_pu',
                                                     'ratedPowerFactor': 'cos_phi', 'ratedU': 'vn_kv',
                                                     'efficiency': 'efficiency_n_percent',
-                                                    'ratedMechanicalPower': 'pn_mech_mw'}, inplace=True)
+                                                    'ratedMechanicalPower': 'pn_mech_mw'})
         eqssh_asynchronous_machines['scaling'] = 1
         eqssh_asynchronous_machines['efficiency_percent'] = 100
         return eqssh_asynchronous_machines

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/generators/energySourcesCim16.py

@@ -38,12 +38,12 @@ class EnergySourceCim16:
             pd.concat([self.cimConverter.cim['eq']['EnergySchedulingType'],
                        self.cimConverter.cim['eq_bd']['EnergySchedulingType']],
                       sort=False)
-        eq_energy_scheduling_type.rename(columns={'rdfId': 'EnergySchedulingType', 'name': 'type'}, inplace=True)
+        eq_energy_scheduling_type = eq_energy_scheduling_type.rename(columns={'rdfId': 'EnergySchedulingType', 'name': 'type'})
         eqssh_energy_sources = self.cimConverter.merge_eq_ssh_profile('EnergySource', add_cim_type_column=True)
         eqssh_energy_sources = pd.merge(eqssh_energy_sources, eq_energy_scheduling_type, how='left',
                                         on='EnergySchedulingType')
         eqssh_energy_sources = pd.merge(eqssh_energy_sources, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eqssh_energy_sources.drop_duplicates(['rdfId'], keep='first', inplace=True)
+        eqssh_energy_sources = eqssh_energy_sources.drop_duplicates(['rdfId'], keep='first')
         sgen_type = dict({'WP': 'WP', 'Wind': 'WP', 'PV': 'PV', 'SolarPV': 'PV', 'BioGas': 'BioGas',
                           'OtherRES': 'OtherRES', 'CHP': 'CHP'})  # todo move?
         eqssh_energy_sources['type'] = eqssh_energy_sources['type'].map(sgen_type)
@@ -55,6 +55,6 @@ class EnergySourceCim16:
         eqssh_energy_sources['scaling'] = 1.
         eqssh_energy_sources['current_source'] = True
         eqssh_energy_sources['generator_type'] = 'current_source'
-        eqssh_energy_sources.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'], 'connected': 'in_service',
-                                             'index_bus': 'bus'}, inplace=True)
+        eqssh_energy_sources = eqssh_energy_sources.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'], 'connected': 'in_service',
+                                             'index_bus': 'bus'})
         return eqssh_energy_sources

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/generators/synchronousMachinesCim16.py

@@ -44,26 +44,26 @@ class SynchronousMachinesCim16:
         eq_generating_units['type'] = 'GeneratingUnit'
         eq_generating_units = pd.concat([eq_generating_units, self.cimConverter.cim['eq']['WindGeneratingUnit']],
                                         sort=False)
-        eq_generating_units['type'].fillna('WP', inplace=True)
+        eq_generating_units['type'] = eq_generating_units['type'].fillna('WP')
         eq_generating_units = pd.concat([eq_generating_units, self.cimConverter.cim['eq']['HydroGeneratingUnit']],
                                         sort=False)
-        eq_generating_units['type'].fillna('Hydro', inplace=True)
+        eq_generating_units['type'] = eq_generating_units['type'].fillna('Hydro')
         eq_generating_units = pd.concat([eq_generating_units, self.cimConverter.cim['eq']['SolarGeneratingUnit']],
                                         sort=False)
-        eq_generating_units['type'].fillna('PV', inplace=True)
+        eq_generating_units['type'] = eq_generating_units['type'].fillna('PV')
         eq_generating_units = pd.concat([eq_generating_units, self.cimConverter.cim['eq']['ThermalGeneratingUnit']],
                                         sort=False)
-        eq_generating_units['type'].fillna('Thermal', inplace=True)
+        eq_generating_units['type'] = eq_generating_units['type'].fillna('Thermal')
         eq_generating_units = pd.concat([eq_generating_units, self.cimConverter.cim['eq']['NuclearGeneratingUnit']],
                                         sort=False)
-        eq_generating_units['type'].fillna('Nuclear', inplace=True)
-        eq_generating_units.rename(columns={'rdfId': 'GeneratingUnit'}, inplace=True)
-        eqssh_synchronous_machines = self.cimConverter.merge_eq_ssh_profile('SynchronousMachine',
-                                                                            add_cim_type_column=True)
+        eq_generating_units['type'] = eq_generating_units['type'].fillna('Nuclear')
+        eq_generating_units = eq_generating_units.rename(columns={'rdfId': 'GeneratingUnit'})
+        eqssh_synchronous_machines = self.cimConverter.merge_eq_ssh_profile(
+            'SynchronousMachine', add_cim_type_column=True)
         if 'type' in eqssh_synchronous_machines.columns:
-            eqssh_synchronous_machines.drop(columns=['type'], inplace=True)
+            eqssh_synchronous_machines = eqssh_synchronous_machines.drop(columns=['type'])
         if 'EquipmentContainer' in eqssh_synchronous_machines.columns:
-            eqssh_synchronous_machines.drop(columns=['EquipmentContainer'], inplace=True)
+            eqssh_synchronous_machines = eqssh_synchronous_machines.drop(columns=['EquipmentContainer'])
         eqssh_synchronous_machines = pd.merge(eqssh_synchronous_machines, eq_generating_units,
                                               how='left', on='GeneratingUnit')
         eqssh_reg_control = self.cimConverter.merge_eq_ssh_profile('RegulatingControl')[
@@ -71,11 +71,11 @@ class SynchronousMachinesCim16:
         # if voltage is not on connectivity node, topological node will be used
         eqtp_terminals = pd.merge(self.cimConverter.cim['eq']['Terminal'], self.cimConverter.cim['tp']['Terminal'],
                                   how='left', on='rdfId')
-        eqtp_terminals.ConnectivityNode.fillna(eqtp_terminals.TopologicalNode, inplace=True)
+        eqtp_terminals.ConnectivityNode = eqtp_terminals.ConnectivityNode.fillna(eqtp_terminals.TopologicalNode)
         eqtp_terminals = eqtp_terminals[['rdfId', 'ConnectivityNode']].rename(
             columns={'rdfId': 'Terminal', 'ConnectivityNode': 'reg_control_cnode'})
         eqssh_reg_control = pd.merge(eqssh_reg_control, eqtp_terminals, how='left', on='Terminal')
-        eqssh_reg_control.drop(columns=['Terminal'], inplace=True)
+        eqssh_reg_control = eqssh_reg_control.drop(columns=['Terminal'])
         # add the voltage from the bus
         eqssh_reg_control = pd.merge(eqssh_reg_control, self.cimConverter.net.bus[['vn_kv', sc['o_id']]].rename(
             columns={sc['o_id']: 'reg_control_cnode'}), how='left', on='reg_control_cnode')
@@ -86,10 +86,10 @@ class SynchronousMachinesCim16:
             how='left', on='RegulatingControl')
         eqssh_synchronous_machines = pd.merge(eqssh_synchronous_machines, self.cimConverter.bus_merge, how='left',
                                               on='rdfId')
-        eqssh_synchronous_machines.drop_duplicates(['rdfId'], keep='first', inplace=True)
+        eqssh_synchronous_machines = eqssh_synchronous_machines.drop_duplicates(['rdfId'], keep='first')
         eqssh_synchronous_machines['vm_pu'] = eqssh_synchronous_machines.targetValue / eqssh_synchronous_machines.vn_kv
         eqssh_synchronous_machines['vm_pu'].fillna(1., inplace=True)
-        eqssh_synchronous_machines.rename(columns={'vn_kv': 'bus_voltage'}, inplace=True)
+        eqssh_synchronous_machines = eqssh_synchronous_machines.rename(columns={'vn_kv': 'bus_voltage'})
         eqssh_synchronous_machines['slack'] = False
         # set the slack = True for gens with highest prio
         # get the highest prio from SynchronousMachines
@@ -101,7 +101,7 @@ class SynchronousMachinesCim16:
         regulation_controllers = self.cimConverter.merge_eq_ssh_profile('RegulatingControl')
         regulation_controllers = regulation_controllers.loc[regulation_controllers['mode'] == 'voltage']
         regulation_controllers = regulation_controllers[['rdfId', 'targetValue', 'enabled']]
-        regulation_controllers.rename(columns={'rdfId': 'RegulatingControl'}, inplace=True)
+        regulation_controllers = regulation_controllers.rename(columns={'rdfId': 'RegulatingControl'})
         enis = pd.merge(enis, regulation_controllers, how='left', on='RegulatingControl')
 
         eni_ref_prio_min = enis.loc[(enis['referencePriority'] > 0) & (enis['enabled']), 'referencePriority'].min()
@@ -132,9 +132,9 @@ class SynchronousMachinesCim16:
         eqssh_synchronous_machines['rx'] = eqssh_synchronous_machines['r2'] / eqssh_synchronous_machines['x2']
         eqssh_synchronous_machines['scaling'] = 1.
         eqssh_synchronous_machines['generator_type'] = 'current_source'
-        eqssh_synchronous_machines.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'],
+        eqssh_synchronous_machines = eqssh_synchronous_machines.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'],
                                                    'connected': 'in_service', 'index_bus': 'bus',
                                                    'minOperatingP': 'min_p_mw', 'maxOperatingP': 'max_p_mw',
                                                    'minQ': 'min_q_mvar', 'maxQ': 'max_q_mvar',
-                                                   'ratedPowerFactor': 'cos_phi'}, inplace=True)
+                                                   'ratedPowerFactor': 'cos_phi'})
         return eqssh_synchronous_machines

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/impedance/equivalentBranchesCim16.py

@@ -77,7 +77,7 @@ class EquivalentBranchesCim16:
                     message="The EquivalentBranch with RDF ID %s has %s Terminals!" % (rdfId, count)))
             eq_eb = eq_eb[0:0]
         # sort by RDF ID and the sequenceNumber to make sure r12 and r21 are in the correct order
-        eq_eb.sort_values(by=['rdfId', 'sequenceNumber'], inplace=True)
+        eq_eb = eq_eb.sort_values(by=['rdfId', 'sequenceNumber'])
         # copy the columns which are needed to reduce the eq_eb to one row per equivalent branch
         eq_eb['rdfId_Terminal2'] = eq_eb['rdfId_Terminal'].copy()
         eq_eb['connected2'] = eq_eb['connected'].copy()
@@ -88,7 +88,7 @@ class EquivalentBranchesCim16:
         eq_eb.rdfId_Terminal2 = eq_eb.rdfId_Terminal2.iloc[1:].reset_index().rdfId_Terminal2
         eq_eb.connected2 = eq_eb.connected2.iloc[1:].reset_index().connected2
         eq_eb.index_bus2 = eq_eb.index_bus2.iloc[1:].reset_index().index_bus2
-        eq_eb.drop_duplicates(['rdfId'], keep='first', inplace=True)
+        eq_eb = eq_eb.drop_duplicates(['rdfId'], keep='first')
         if hasattr(self.cimConverter.net, 'sn_mva'):
             eq_eb['sn_mva'] = self.cimConverter.net['sn_mva']
         else:
@@ -104,6 +104,6 @@ class EquivalentBranchesCim16:
         eq_eb['rtf0_pu'] = eq_eb['zeroR21'] / eq_eb['z_base']
         eq_eb['xtf0_pu'] = eq_eb['zeroX21'] / eq_eb['z_base']
         eq_eb['in_service'] = eq_eb.connected & eq_eb.connected2
-        eq_eb.rename(columns={'rdfId_Terminal': sc['t_from'], 'rdfId_Terminal2': sc['t_to'], 'rdfId': sc['o_id'],
-                              'index_bus': 'from_bus', 'index_bus2': 'to_bus'}, inplace=True)
+        eq_eb = eq_eb.rename(columns={'rdfId_Terminal': sc['t_from'], 'rdfId_Terminal2': sc['t_to'], 'rdfId': sc['o_id'],
+                              'index_bus': 'from_bus', 'index_bus2': 'to_bus'})
         return eq_eb

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/impedance/seriesCompensatorsCim16.py

@@ -74,7 +74,7 @@ class SeriesCompensatorsCim16:
                     message="The SeriesCompensator with RDF ID %s has %s Terminals!" % (rdfId, count)))
             eq_sc = eq_sc[0:0]
         # sort by RDF ID and the sequenceNumber to make sure r12 and r21 are in the correct order
-        eq_sc.sort_values(by=['rdfId', 'sequenceNumber'], inplace=True)
+        eq_sc = eq_sc.sort_values(by=['rdfId', 'sequenceNumber'])
         # copy the columns which are needed to reduce the eq_sc to one row per equivalent branch
         eq_sc['rdfId_Terminal2'] = eq_sc['rdfId_Terminal'].copy()
         eq_sc['connected2'] = eq_sc['connected'].copy()
@@ -85,7 +85,7 @@ class SeriesCompensatorsCim16:
         eq_sc.rdfId_Terminal2 = eq_sc.rdfId_Terminal2.iloc[1:].reset_index().rdfId_Terminal2
         eq_sc.connected2 = eq_sc.connected2.iloc[1:].reset_index().connected2
         eq_sc.index_bus2 = eq_sc.index_bus2.iloc[1:].reset_index().index_bus2
-        eq_sc.drop_duplicates(['rdfId'], keep='first', inplace=True)
+        eq_sc = eq_sc.drop_duplicates(['rdfId'], keep='first')
         if hasattr(self.cimConverter.net, 'sn_mva'):
             eq_sc['sn_mva'] = self.cimConverter.net['sn_mva']
         else:
@@ -101,6 +101,6 @@ class SeriesCompensatorsCim16:
         eq_sc['rtf0_pu'] = eq_sc['r0'] / eq_sc['z_base']
         eq_sc['xtf0_pu'] = eq_sc['x0'] / eq_sc['z_base']
         eq_sc['in_service'] = eq_sc.connected & eq_sc.connected2
-        eq_sc.rename(columns={'rdfId_Terminal': sc['t_from'], 'rdfId_Terminal2': sc['t_to'], 'rdfId': sc['o_id'],
-                              'index_bus': 'from_bus', 'index_bus2': 'to_bus'}, inplace=True)
+        eq_sc = eq_sc.rename(columns={'rdfId_Terminal': sc['t_from'], 'rdfId_Terminal2': sc['t_to'], 'rdfId': sc['o_id'],
+                              'index_bus': 'from_bus', 'index_bus2': 'to_bus'})
         return eq_sc

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/lines/acLineSegmentsCim16.py

@@ -27,10 +27,10 @@ class AcLineSegmentsCim16:
         # -------- lines --------
         if 'line' in eq_ac_line_segments['kindOfType'].values:
             line_df = eq_ac_line_segments.loc[eq_ac_line_segments['kindOfType'] == 'line']
-            line_df.rename(columns={
+            line_df = line_df.rename(columns={
                 'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t_from'], 'rdfId_Terminal2': sc['t_to'],
                 'index_bus': 'from_bus', 'index_bus2': 'to_bus', 'length': 'length_km',
-                'shortCircuitEndTemperature': 'endtemp_degree'}, inplace=True)
+                'shortCircuitEndTemperature': 'endtemp_degree'})
             line_df[sc['o_cl']] = 'ACLineSegment'
             line_df['in_service'] = line_df.connected & line_df.connected2
             line_df['r_ohm_per_km'] = abs(line_df.r) / line_df.length_km
@@ -52,9 +52,9 @@ class AcLineSegmentsCim16:
         if 'switch' in eq_ac_line_segments['kindOfType'].values:
             switch_df = eq_ac_line_segments.loc[eq_ac_line_segments['kindOfType'] == 'switch']
 
-            switch_df.rename(columns={
+            switch_df = switch_df.rename(columns={
                 'rdfId': sc['o_id'], 'index_bus': 'bus', 'index_bus2': 'element', 'rdfId_Terminal': sc['t_bus'],
-                'rdfId_Terminal2': sc['t_ele']}, inplace=True)
+                'rdfId_Terminal2': sc['t_ele']})
             switch_df['et'] = 'b'
             switch_df['type'] = None
             switch_df['z_ohm'] = 0
@@ -107,20 +107,20 @@ class AcLineSegmentsCim16:
         eq_ac_line_segments.reset_index(inplace=True)
         # now merge with OperationalLimitSets and CurrentLimits
         eq_operational_limit_sets = self.cimConverter.cim['eq']['OperationalLimitSet'][['rdfId', 'Terminal']]
-        eq_operational_limit_sets.rename(columns={'rdfId': 'rdfId_OperationalLimitSet',
-                                                  'Terminal': 'rdfId_Terminal'}, inplace=True)
+        eq_operational_limit_sets = eq_operational_limit_sets.rename(columns={'rdfId': 'rdfId_OperationalLimitSet',
+                                                  'Terminal': 'rdfId_Terminal'})
         eq_ac_line_segments = pd.merge(eq_ac_line_segments, eq_operational_limit_sets, how='left',
                                        on='rdfId_Terminal')
         eq_current_limits = self.cimConverter.cim['eq']['CurrentLimit'][['rdfId', 'OperationalLimitSet', 'value']]
-        eq_current_limits.rename(columns={'rdfId': 'rdfId_CurrentLimit',
-                                          'OperationalLimitSet': 'rdfId_OperationalLimitSet'}, inplace=True)
+        eq_current_limits = eq_current_limits.rename(columns={'rdfId': 'rdfId_CurrentLimit',
+                                          'OperationalLimitSet': 'rdfId_OperationalLimitSet'})
         eq_ac_line_segments = pd.merge(eq_ac_line_segments, eq_current_limits, how='left',
                                        on='rdfId_OperationalLimitSet')
         eq_ac_line_segments.value = eq_ac_line_segments.value.astype(float)
         # sort by rdfId, sequenceNumber and value. value is max_i_ka, choose the lowest one if more than one is
         # given (A line may have more than one max_i_ka in CIM, different modes e.g. normal)
-        eq_ac_line_segments.sort_values(by=['rdfId', 'sequenceNumber', 'value'], inplace=True)
-        eq_ac_line_segments.drop_duplicates(['rdfId', 'rdfId_Terminal'], keep='first', inplace=True)
+        eq_ac_line_segments = eq_ac_line_segments.sort_values(by=['rdfId', 'sequenceNumber', 'value'])
+        eq_ac_line_segments = eq_ac_line_segments.drop_duplicates(['rdfId', 'rdfId_Terminal'], keep='first')
 
         # copy the columns which are needed to reduce the eq_ac_line_segments to one row per line
         eq_ac_line_segments['rdfId_Terminal2'] = eq_ac_line_segments['rdfId_Terminal'].copy()
@@ -135,7 +135,7 @@ class AcLineSegmentsCim16:
         eq_ac_line_segments.connected2 = eq_ac_line_segments.connected2.iloc[1:].reset_index().connected2
         eq_ac_line_segments.index_bus2 = eq_ac_line_segments.index_bus2.iloc[1:].reset_index().index_bus2
         eq_ac_line_segments.value2 = eq_ac_line_segments.value2.iloc[1:].reset_index().value2
-        eq_ac_line_segments.drop_duplicates(['rdfId'], keep='first', inplace=True)
+        eq_ac_line_segments = eq_ac_line_segments.drop_duplicates(['rdfId'], keep='first')
         # get the max_i_ka
         eq_ac_line_segments['max_i_ka'] = eq_ac_line_segments['value'].fillna(eq_ac_line_segments['value2']) * 1e-3
 

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/lines/dcLineSegmentsCim16.py

@@ -66,11 +66,11 @@ class DcLineSegmentsCim16:
                       ignore_index=True, sort=False),
             how='left', on='rdfId')
         if 'name' in converters.columns:
-            converters.drop(columns=['name'], inplace=True)
+            converters = converters.drop(columns=['name'])
         # merge with the terminals
         converters = pd.merge(converters, self.cimConverter.bus_merge, how='left', on='rdfId')
-        converters.drop(columns=['sequenceNumber'], inplace=True)
-        converters.rename(columns={'rdfId': 'converters'}, inplace=True)
+        converters = converters.drop(columns=['sequenceNumber'])
+        converters = converters.rename(columns={'rdfId': 'converters'})
         converter_terminals = pd.concat(
             [self.cimConverter.cim['eq']['Terminal'], self.cimConverter.cim['eq_bd']['Terminal']],
             ignore_index=True, sort=False)
@@ -81,7 +81,7 @@ class DcLineSegmentsCim16:
                                     how='left', on='ConnectivityNode')
         # get the missing converters (maybe there is a switch or something else between the line and the converter)
         t = self.cimConverter.cim['eq']['DCTerminal'][['DCNode', 'DCConductingEquipment', 'sequenceNumber']]
-        t.rename(columns={'DCNode': 'ConnectivityNode', 'DCConductingEquipment': 'ConductingEquipment'}, inplace=True)
+        t = t.rename(columns={'DCNode': 'ConnectivityNode', 'DCConductingEquipment': 'ConductingEquipment'})
 
         def search_converter(cn_ids: Dict[str, str], visited_cns: List[str]) -> str:
             new_cn_dict = dict()
@@ -116,12 +116,12 @@ class DcLineSegmentsCim16:
                     level=LogLevel.WARNING, code=ReportCode.WARNING_CONVERTING,
                     message="Error processing the DCLineSegments, there is a problem with Terminals in the source "
                             "data!"))
-        dc_line_segments.drop(columns=['ConnectivityNode'], inplace=True)
+        dc_line_segments = dc_line_segments.drop(columns=['ConnectivityNode'])
         dc_line_segments = pd.merge(dc_line_segments, converters_t, how='left', on='converters')
         dc_line_segments['targetUpcc'].fillna(dc_line_segments['base_voltage_bus'], inplace=True)
 
         # copy the columns which are needed to reduce the dc_line_segments to one row per line
-        dc_line_segments.sort_values(by=['rdfId', 'sequenceNumber'], inplace=True)
+        dc_line_segments = dc_line_segments.sort_values(by=['rdfId', 'sequenceNumber'])
         # a list of DC line parameters which are used for each DC line end
         dc_line_segments.reset_index(inplace=True)
         copy_list = ['index_bus', 'rdfId_Terminal', 'connected', 'p', 'ratedUdc', 'targetUpcc', 'base_voltage_bus']
@@ -131,7 +131,7 @@ class DcLineSegmentsCim16:
             # cut the first element from the copied columns
             dc_line_segments[one_item + '2'] = dc_line_segments[one_item + '2'].iloc[1:].reset_index()[one_item + '2']
         del copy_list, one_item
-        dc_line_segments.drop_duplicates(['rdfId'], keep='first', inplace=True)
+        dc_line_segments = dc_line_segments.drop_duplicates(['rdfId'], keep='first')
         dc_line_segments = pd.merge(dc_line_segments,
                                     pd.DataFrame(dc_line_segments.pivot_table(index=['converters'], aggfunc='size'),
                                                  columns=['converter_dups']), how='left', on='converters')
@@ -142,8 +142,8 @@ class DcLineSegmentsCim16:
         dc_line_segments['vm_from_pu'] = dc_line_segments['targetUpcc'] / dc_line_segments['base_voltage_bus']
         dc_line_segments['vm_to_pu'] = dc_line_segments['targetUpcc2'] / dc_line_segments['base_voltage_bus2']
         dc_line_segments['in_service'] = dc_line_segments.connected & dc_line_segments.connected2
-        dc_line_segments.rename(columns={
+        dc_line_segments = dc_line_segments.rename(columns={
             'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t_from'], 'rdfId_Terminal2': sc['t_to'], 'index_bus': 'from_bus',
-            'index_bus2': 'to_bus'}, inplace=True)
+            'index_bus2': 'to_bus'})
 
         return dc_line_segments

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/loads/conformLoadsCim16.py

@@ -31,8 +31,8 @@ class ConformLoadsCim16:
     def _prepare_conform_loads_cim16(self) -> pd.DataFrame:
         eqssh_conform_loads = self.cimConverter.merge_eq_ssh_profile('ConformLoad', add_cim_type_column=True)
         eqssh_conform_loads = pd.merge(eqssh_conform_loads, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eqssh_conform_loads.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
-                                            'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'}, inplace=True)
+        eqssh_conform_loads = eqssh_conform_loads.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
+                                            'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'})
         eqssh_conform_loads['const_i_percent'] = 0.
         eqssh_conform_loads['const_z_percent'] = 0.
         eqssh_conform_loads['scaling'] = 1.

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/loads/energyConcumersCim16.py

@@ -31,8 +31,8 @@ class EnergyConsumersCim16:
     def _prepare_energy_consumers_cim16(self) -> pd.DataFrame:
         eqssh_energy_consumers = self.cimConverter.merge_eq_ssh_profile('EnergyConsumer', add_cim_type_column=True)
         eqssh_energy_consumers = pd.merge(eqssh_energy_consumers, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eqssh_energy_consumers.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
-                                               'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'}, inplace=True)
+        eqssh_energy_consumers = eqssh_energy_consumers.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
+                                               'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'})
         eqssh_energy_consumers['const_i_percent'] = 0.
         eqssh_energy_consumers['const_z_percent'] = 0.
         eqssh_energy_consumers['scaling'] = 1.

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/loads/nonConformLoadsCim16.py

@@ -31,8 +31,8 @@ class NonConformLoadsCim16:
     def _prepare_non_conform_loads_cim16(self) -> pd.DataFrame:
         eqssh_non_conform_loads = self.cimConverter.merge_eq_ssh_profile('NonConformLoad', add_cim_type_column=True)
         eqssh_non_conform_loads = pd.merge(eqssh_non_conform_loads, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eqssh_non_conform_loads.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
-                                                'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'}, inplace=True)
+        eqssh_non_conform_loads = eqssh_non_conform_loads.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
+                                                'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'})
         eqssh_non_conform_loads['const_i_percent'] = 0.
         eqssh_non_conform_loads['const_z_percent'] = 0.
         eqssh_non_conform_loads['scaling'] = 1.

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/loads/stationSuppliesCim16.py

@@ -31,8 +31,8 @@ class StationSuppliesCim16:
     def _prepare_station_supplies_cim16(self) -> pd.DataFrame:
         eqssh_station_supplies = self.cimConverter.merge_eq_ssh_profile('StationSupply', add_cim_type_column=True)
         eqssh_station_supplies = pd.merge(eqssh_station_supplies, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eqssh_station_supplies.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
-                                               'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'}, inplace=True)
+        eqssh_station_supplies = eqssh_station_supplies.rename(columns={'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'index_bus': 'bus',
+                                               'connected': 'in_service', 'p': 'p_mw', 'q': 'q_mvar'})
         eqssh_station_supplies['const_i_percent'] = 0.
         eqssh_station_supplies['const_z_percent'] = 0.
         eqssh_station_supplies['scaling'] = 1.

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/shunts/linearShuntCompensatorCim16.py

@@ -32,9 +32,9 @@ class LinearShuntCompensatorCim16:
     def _prepare_linear_shunt_compensator_cim16(self) -> pd.DataFrame:
         eqssh_shunts = self.cimConverter.merge_eq_ssh_profile('LinearShuntCompensator', add_cim_type_column=True)
         eqssh_shunts = pd.merge(eqssh_shunts, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eqssh_shunts.rename(columns={
+        eqssh_shunts = eqssh_shunts.rename(columns={
             'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'connected': 'in_service', 'index_bus': 'bus',
-            'nomU': 'vn_kv', 'sections': 'step', 'maximumSections': 'max_step'}, inplace=True)
+            'nomU': 'vn_kv', 'sections': 'step', 'maximumSections': 'max_step'})
         y = eqssh_shunts['gPerSection'] + eqssh_shunts['bPerSection'] * 1j
         s = eqssh_shunts['vn_kv'] ** 2 * np.conj(y)
         eqssh_shunts['p_mw'] = s.values.real

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/shunts/nonLinearShuntCompensatorCim16.py

@@ -59,9 +59,9 @@ class NonLinearShuntCompensatorCim16:
                 eqssh_shunts.loc[eqssh_shunts['sections'] >= eqssh_shunts['sectionNumber'], 'q'] = \
                     eqssh_shunts['q'] + eqssh_shunts['q_temp']
             eqssh_shunts = eqssh_shunts[eqssh_shunts_cols]
-        eqssh_shunts.rename(columns={
+        eqssh_shunts = eqssh_shunts.rename(columns={
             'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'connected': 'in_service', 'index_bus': 'bus',
-            'nomU': 'vn_kv', 'p': 'p_mw', 'q': 'q_mvar'}, inplace=True)
+            'nomU': 'vn_kv', 'p': 'p_mw', 'q': 'q_mvar'})
         eqssh_shunts['step'] = 1
         eqssh_shunts['max_step'] = 1
         return eqssh_shunts

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/shunts/staticVarCompensatorCim16.py

@@ -31,7 +31,7 @@ class StaticVarCompensatorCim16:
     def _prepare_static_var_compensator_cim16(self) -> pd.DataFrame:
         eq_stat_coms = self.cimConverter.merge_eq_ssh_profile('StaticVarCompensator', True)
         eq_stat_coms = pd.merge(eq_stat_coms, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eq_stat_coms.rename(columns={'q': 'q_mvar'}, inplace=True)
+        eq_stat_coms = eq_stat_coms.rename(columns={'q': 'q_mvar'})
         # get the active power and reactive power from SV profile
         eq_stat_coms = pd.merge(eq_stat_coms, self.cimConverter.cim['sv']['SvPowerFlow'][['p', 'q', 'Terminal']],
                                 how='left', left_on='rdfId_Terminal', right_on='Terminal')

{pandapower-2.14.2 → pandapower-2.14.6}/pandapower/converter/cim/cim2pp/converter_classes/switches/switchesCim16.py

@@ -50,7 +50,7 @@ class SwitchesCim16:
             ignore_index=True, sort=False)
         eqssh_switches.type[start_index_cim_net:] = 'LS'
         # drop all duplicates to fix class inherit problem in jpa
-        eqssh_switches.drop_duplicates(subset=['rdfId'], keep='first', inplace=True)
+        eqssh_switches = eqssh_switches.drop_duplicates(subset=['rdfId'], keep='first')
         switch_length_before_merge = eqssh_switches.index.size
         # until now eqssh_switches looks like:
         #   rdfId   name    open    ...
@@ -58,7 +58,7 @@ class SwitchesCim16:
         #   _x02    switch2 False   ...
         # now join with the terminals
         eqssh_switches = pd.merge(eqssh_switches, self.cimConverter.bus_merge, how='left', on='rdfId')
-        eqssh_switches.sort_values(by=['rdfId', 'sequenceNumber'], inplace=True)
+        eqssh_switches = eqssh_switches.sort_values(by=['rdfId', 'sequenceNumber'])
         eqssh_switches.reset_index(inplace=True)
         # copy the columns which are needed to reduce the eqssh_switches to one line per switch
         eqssh_switches['rdfId_Terminal2'] = eqssh_switches['rdfId_Terminal'].copy()
@@ -70,7 +70,7 @@ class SwitchesCim16:
             eqssh_switches.rdfId_Terminal2 = eqssh_switches.rdfId_Terminal2.iloc[1:].reset_index().rdfId_Terminal2
             eqssh_switches.connected2 = eqssh_switches.connected2.iloc[1:].reset_index().connected2
             eqssh_switches.index_bus2 = eqssh_switches.index_bus2.iloc[1:].reset_index().index_bus2
-            eqssh_switches.drop_duplicates(subset=['rdfId'], keep='first', inplace=True)
+            eqssh_switches = eqssh_switches.drop_duplicates(subset=['rdfId'], keep='first')
         else:
             self.logger.error("Something went wrong at switches, seems like that terminals for connection with "
                               "connectivity nodes are missing!")
@@ -87,8 +87,8 @@ class SwitchesCim16:
                     level=LogLevel.WARNING, code=ReportCode.WARNING_CONVERTING,
                     message="The switch with RDF ID %s has %s Terminals!" % (rdfId, count)))
             eqssh_switches = eqssh_switches[0:0]
-        eqssh_switches.rename(columns={'rdfId': sc['o_id'], 'index_bus': 'bus', 'index_bus2': 'element',
-                                       'rdfId_Terminal': sc['t_bus'], 'rdfId_Terminal2': sc['t_ele']}, inplace=True)
+        eqssh_switches = eqssh_switches.rename(columns={'rdfId': sc['o_id'], 'index_bus': 'bus', 'index_bus2': 'element',
+                                       'rdfId_Terminal': sc['t_bus'], 'rdfId_Terminal2': sc['t_ele']})
         eqssh_switches['et'] = 'b'
         eqssh_switches['z_ohm'] = 0
         if eqssh_switches.index.size > 0: