pydae 0.57.1__py3-none-any.whl → 0.57.3__py3-none-any.whl

pydae/__init__.py

@@ -7,5 +7,5 @@ Differential Algebraic Equations in Python
 
 """
 
-__version__ = "0.57.1"
+__version__ = "0.57.3"
  

pydae/bmapu/bmapu_builder.py

@@ -20,6 +20,7 @@ from pydae.bmapu.sources.sources import add_sources
 from pydae.bmapu.miscellaneous.miscellaneous import add_miscellaneous
 from pydae.bmapu.pods.pods import add_pods
 from pydae.bmapu.miscellaneous.banks import add_banks
+from pydae.bmapu.lines.lines import add_lines
 
 import pydae.build_cffi as db
 from pydae.build_v2 import builder
@@ -90,10 +91,8 @@ class bmapu:
         self.transformers = data['transformers']
         self.loads = data['loads']
 
-        self.x_grid = []
-        self.f_grid = []
-    
-        self.params_grid = {'S_base':self.system['S_base']}
+   
+        
         self.S_base = sym.Symbol("S_base", real=True) 
         self.N_bus = len(self.buses)
         self.N_branch = 3*len(self.lines) + len(self.shunts) + 2*len(self.transformers)
@@ -101,6 +100,8 @@ class bmapu:
         self.dae = {'f':[],'g':[],'x':[],'y_ini':[],'y_run':[],
                     'u_ini_dict':{},'u_run_dict':{},'params_dict':{},
                     'h_dict':{},'xy_0_dict':{}}
+        
+        self.dae['params_dict'].update({'S_base':self.system['S_base']})
 
         self.uz_jacs = True     
         self.verbose = False   
@@ -114,105 +115,104 @@ class bmapu:
         
         S_base = sym.Symbol('S_base', real=True)
         
-        xy_0_dict_grid = {}
-        u_grid = {}
-        h_grid = {}
-        
-        A = sym.zeros(N_branch,N_bus)
-        G_primitive = sym.zeros(N_branch,N_branch)
-        B_primitive = sym.zeros(N_branch,N_branch)
-        buses_list = [bus['name'] for bus in self.buses]
-        it = 0
-        for line in self.lines:
+       
+        self.A = sym.zeros(N_branch,N_bus)
+        self.G_primitive = sym.zeros(N_branch,N_branch)
+        self.B_primitive = sym.zeros(N_branch,N_branch)
+        self.buses_list = [bus['name'] for bus in self.buses]
+        self.it = 0
+
+        add_lines(self) 
+        # for line in self.lines:
     
-            bus_j = line['bus_j']
-            bus_k = line['bus_k']
+        #     bus_j = line['bus_j']
+        #     bus_k = line['bus_k']
     
-            idx_j = buses_list.index(bus_j)
-            idx_k = buses_list.index(bus_k)    
+        #     idx_j = self.buses_list.index(bus_j)
+        #     idx_k = self.buses_list.index(bus_k)    
     
-            A[it,idx_j] = 1
-            A[it,idx_k] =-1   
-            A[it+1,idx_j] = 1
-            A[it+2,idx_k] = 1   
+        #     A[self.self.it,idx_j] = 1
+        #     A[self.self.it,idx_k] =-1   
+        #     A[self.self.it+1,idx_j] = 1
+        #     A[self.self.it+2,idx_k] = 1   
             
-            line_name = f"{bus_j}_{bus_k}"
-            g_jk = sym.Symbol(f"g_{line_name}", real=True) 
-            b_jk = sym.Symbol(f"b_{line_name}", real=True) 
-            bs_jk = sym.Symbol(f"bs_{line_name}", real=True) 
-            G_primitive[it,it] = g_jk
-            B_primitive[it,it] = b_jk
-            B_primitive[it+1,it+1] = bs_jk/2
-            B_primitive[it+2,it+2] = bs_jk/2
-
-            if not 'thermal' in line:
-                line.update({'thermal':False})      
-
-            if 'X_pu' in line:
-                if 'S_mva' in line: S_line = 1e6*line['S_mva']
-                R = line['R_pu']*sys['S_base']/S_line  # in pu of the system base
-                X = line['X_pu']*sys['S_base']/S_line  # in pu of the system base
-                G =  R/(R**2+X**2)
-                B = -X/(R**2+X**2)
-                self.params_grid.update({f"g_{line_name}":G})
-                self.params_grid.update({f'b_{line_name}':B})
+        #     line_name = f"{bus_j}_{bus_k}"
+        #     g_jk = sym.Symbol(f"g_{line_name}", real=True) 
+        #     b_jk = sym.Symbol(f"b_{line_name}", real=True) 
+        #     bs_jk = sym.Symbol(f"bs_{line_name}", real=True) 
+        #     G_primitive[self.it,self.it] = g_jk
+        #     B_primitive[self.it,self.it] = b_jk
+        #     B_primitive[self.it+1,self.it+1] = bs_jk/2
+        #     B_primitive[self.it+2,self.it+2] = bs_jk/2
+
+        #     if not 'thermal' in line:
+        #         line.update({'thermal':False})      
+
+        #     if 'X_pu' in line:
+        #         if 'S_mva' in line: S_line = 1e6*line['S_mva']
+        #         R = line['R_pu']*sys['S_base']/S_line  # in pu of the system base
+        #         X = line['X_pu']*sys['S_base']/S_line  # in pu of the system base
+        #         G =  R/(R**2+X**2)
+        #         B = -X/(R**2+X**2)
+        #         self.dae['params_dict'].update({f"g_{line_name}":G})
+        #         self.dae['params_dict'].update({f'b_{line_name}':B})
     
-            if 'X' in line:
-                bus_idx = buses_list.index(line['bus_j'])
-                U_base = self.buses[bus_idx]['U_kV']*1000
-                Z_base = U_base**2/sys['S_base']
-                R = line['R']/Z_base  # in pu of the system base
-                X = line['X']/Z_base  # in pu of the system base
-                G =  R/(R**2+X**2)
-                B = -X/(R**2+X**2)
-                self.params_grid.update({f"g_{line_name}":G})
-                self.params_grid.update({f'b_{line_name}':B})
+        #     if 'X' in line:
+        #         bus_idx = self.buses_list.index(line['bus_j'])
+        #         U_base = self.buses[bus_idx]['U_kV']*1000
+        #         Z_base = U_base**2/sys['S_base']
+        #         R = line['R']/Z_base  # in pu of the system base
+        #         X = line['X']/Z_base  # in pu of the system base
+        #         G =  R/(R**2+X**2)
+        #         B = -X/(R**2+X**2)
+        #         self.dae['params_dict'].update({f"g_{line_name}":G})
+        #         self.dae['params_dict'].update({f'b_{line_name}':B})
     
-            if 'X_km' in line:
-                bus_idx = buses_list.index(line['bus_j'])
-                U_base = self.buses[bus_idx]['U_kV']*1000
-                Z_base = U_base**2/sys['S_base']
-                if line['thermal']:
-                    R = sym.Symbol(f"R_{line_name}", real=True)
-                    R_N = line['R_km']*line['km']/Z_base  # in pu of the system base
-                    u_grid.update({str(R):R_N})
-                else:    
-                    R = line['R_km']*line['km']/Z_base  # in pu of the system base
-
-                X = line['X_km']*line['km']/Z_base  # in pu of the system base
-                G =  R/(R**2+X**2)
-                B = -X/(R**2+X**2)
-                self.params_grid.update({f"g_{line_name}":G})
-                self.params_grid.update({f'b_{line_name}':B})        
+        #     if 'X_km' in line:
+        #         bus_idx = self.buses_list.index(line['bus_j'])
+        #         U_base = self.buses[bus_idx]['U_kV']*1000
+        #         Z_base = U_base**2/sys['S_base']
+        #         if line['thermal']:
+        #             R = sym.Symbol(f"R_{line_name}", real=True)
+        #             R_N = line['R_km']*line['km']/Z_base  # in pu of the system base
+        #             self.dae['u_ini_dict'].update({str(R):R_N})
+        #         else:    
+        #             R = line['R_km']*line['km']/Z_base  # in pu of the system base
+
+        #         X = line['X_km']*line['km']/Z_base  # in pu of the system base
+        #         G =  R/(R**2+X**2)
+        #         B = -X/(R**2+X**2)
+        #         self.dae['params_dict'].update({f"g_{line_name}":G})
+        #         self.dae['params_dict'].update({f'b_{line_name}':B})        
     
-            self.params_grid.update({f'bs_{line_name}':0.0})
-            if 'Bs_pu' in line:
-                if 'S_mva' in line: S_line = 1e6*line['S_mva']
-                Bs = line['Bs_pu']*S_line/sys['S_base']  # in pu of the system base
-                bs = Bs
-                self.params_grid[f'bs_{line_name}'] = bs
+        #     self.dae['params_dict'].update({f'bs_{line_name}':0.0})
+        #     if 'Bs_pu' in line:
+        #         if 'S_mva' in line: S_line = 1e6*line['S_mva']
+        #         Bs = line['Bs_pu']*S_line/sys['S_base']  # in pu of the system base
+        #         bs = Bs
+        #         self.dae['params_dict'][f'bs_{line_name}'] = bs
      
-            if 'Bs_km' in line:
-                bus_idx = buses_list.index(line['bus_j'])
-                U_base = self.buses[bus_idx]['U_kV']*1000
-                Z_base = U_base**2/sys['S_base']
-                Y_base = 1.0/Z_base
-                Bs = line['Bs_km']*line['km']/Y_base # in pu of the system base
-                bs = Bs 
-                self.params_grid[f'bs_{line_name}'] = bs
+        #     if 'Bs_km' in line:
+        #         bus_idx = self.buses_list.index(line['bus_j'])
+        #         U_base = self.buses[bus_idx]['U_kV']*1000
+        #         Z_base = U_base**2/sys['S_base']
+        #         Y_base = 1.0/Z_base
+        #         Bs = line['Bs_km']*line['km']/Y_base # in pu of the system base
+        #         bs = Bs 
+        #         self.dae['params_dict'][f'bs_{line_name}'] = bs
                 
-            it += 3
+        #     self.it += 3
 
         for trafo in self.transformers:
     
             bus_j = trafo['bus_j']
             bus_k = trafo['bus_k']
     
-            idx_j = buses_list.index(bus_j)
-            idx_k = buses_list.index(bus_k)    
+            idx_j = self.buses_list.index(bus_j)
+            idx_k = self.buses_list.index(bus_k)    
     
-            A[it,idx_j] = 1
-            A[it+1,idx_k] = 1  
+            self.A[self.it,idx_j] = 1
+            self.A[self.it+1,idx_k] = 1  
             
             trafo_name = f"{bus_j}_{bus_k}"
             g_jk = sym.Symbol(f"g_cc_{trafo_name}", real=True) 
@@ -229,8 +229,8 @@ class bmapu:
                                      [-Y_cc/(a_s+sym.I*b_s),                 Y_cc]])
 
 
-            G_primitive[it:it+2,it:it+2] = sym.re(Y_primitive)
-            B_primitive[it:it+2,it:it+2] = sym.im(Y_primitive)
+            self.G_primitive[self.it:self.it+2,self.it:self.it+2] = sym.re(Y_primitive)
+            self.B_primitive[self.it:self.it+2,self.it:self.it+2] = sym.im(Y_primitive)
 
 
             if 'X_pu' in trafo:
@@ -239,43 +239,43 @@ class bmapu:
                 X = trafo['X_pu']*sys['S_base']/S_trafo  # in pu of the system base
                 G =  R/(R**2+X**2)
                 B = -X/(R**2+X**2)
-                self.params_grid.update({f"g_cc_{trafo_name}":G})
-                self.params_grid.update({f'b_cc_{trafo_name}':B})
+                self.dae['params_dict'].update({f"g_cc_{trafo_name}":G})
+                self.dae['params_dict'].update({f'b_cc_{trafo_name}':B})
                 tap_m = 1.0
                 if 'tap_m' in trafo:
                     tap_m = trafo['tap_m']
-                self.params_grid.update({f'tap_{trafo_name}':tap_m})
-                self.params_grid.update({f'ang_{trafo_name}':0.0})
+                self.dae['params_dict'].update({f'tap_{trafo_name}':tap_m})
+                self.dae['params_dict'].update({f'ang_{trafo_name}':0.0})
 
     
             if 'X' in trafo:
-                bus_idx = buses_list.index(trafo['bus_j'])
+                bus_idx = self.buses_list.index(trafo['bus_j'])
                 U_base = self.buses[bus_idx]['U_kV']*1000
                 Z_base = U_base**2/sys['S_base']
                 R = trafo['R']/Z_base  # in pu of the system base
                 X = trafo['X']/Z_base  # in pu of the system base
                 G =  R/(R**2+X**2)
                 B = -X/(R**2+X**2)
-                self.params_grid.update({f"g_cc_{trafo_name}":G})
-                self.params_grid.update({f'b_cc_{trafo_name}':B})
-                self.params_grid.update({f'tap_{trafo_name}':1.0})
-                self.params_grid.update({f'ang_{trafo_name}':0.0})
+                self.dae['params_dict'].update({f"g_cc_{trafo_name}":G})
+                self.dae['params_dict'].update({f'b_cc_{trafo_name}':B})
+                self.dae['params_dict'].update({f'tap_{trafo_name}':1.0})
+                self.dae['params_dict'].update({f'ang_{trafo_name}':0.0})
      
-            it += 2
+            self.it += 2
 
 
         for shunt in self.shunts:
     
             bus_j = shunt['bus']   
-            idx_j = buses_list.index(bus_j)
+            idx_j = self.buses_list.index(bus_j)
     
-            A[it,idx_j] = 1
+            self.A[self.it,idx_j] = 1
              
             shunt_name = f"{bus_j}"
             g_j = sym.Symbol(f"g_shunt_{shunt_name}", real=True) 
             b_j = sym.Symbol(f"b_shunt_{shunt_name}", real=True) 
-            G_primitive[it,it] = g_j
-            B_primitive[it,it] = b_j
+            self.G_primitive[self.it,self.it] = g_j
+            self.B_primitive[self.it,self.it] = b_j
 
             
             if 'X_pu' in shunt:
@@ -284,8 +284,8 @@ class bmapu:
                 X = shunt['X_pu']*sys['S_base']/S_line  # in pu of the system base
                 G =  R/(R**2+X**2)
                 B = -X/(R**2+X**2)
-                self.params_grid.update({f"g_shunt_{shunt_name}":G})
-                self.params_grid.update({f'b_shunt_{shunt_name}':B})
+                self.dae['params_dict'].update({f"g_shunt_{shunt_name}":G})
+                self.dae['params_dict'].update({f'b_shunt_{shunt_name}':B})
     
             if 'X' in shunt:
                 U_base = self.buses[idx_j]['U_kV']*1000
@@ -294,56 +294,63 @@ class bmapu:
                 X = shunt['X']/Z_base  # in pu of the system base
                 G =  R/(R**2+X**2)
                 B = -X/(R**2+X**2)
-                self.params_grid.update({f"g_shunt_{shunt_name}":G})
-                self.params_grid.update({f'b_shunt_{shunt_name}':B})
+                self.dae['params_dict'].update({f"g_shunt_{shunt_name}":G})
+                self.dae['params_dict'].update({f'b_shunt_{shunt_name}':B})
                 
-            it += 1    
+            self.it += 1    
     
-        G = A.T * G_primitive * A
-        B = A.T * B_primitive * A    
+        G = self.A.T * self.G_primitive * self.A
+        B = self.A.T * self.B_primitive * self.A    
         
         sin = sym.sin
         cos = sym.cos
-        y_grid = []
         g = sym.zeros(2*N_bus,1)
 
         for j in range(N_bus):
-            bus_j_name = buses_list[j]
+            bus_j_name = self.buses_list[j]
             P_j = sym.Symbol(f"P_{bus_j_name}", real=True)
             Q_j = sym.Symbol(f"Q_{bus_j_name}", real=True)
             g[2*j]   = -P_j/S_base
             g[2*j+1] = -Q_j/S_base
             for k in range(N_bus): 
     
-                bus_k_name = buses_list[k]
+                bus_k_name = self.buses_list[k]
                 V_j = sym.Symbol(f"V_{bus_j_name}", real=True) 
                 V_k = sym.Symbol(f"V_{bus_k_name}", real=True) 
                 theta_j = sym.Symbol(f"theta_{bus_j_name}", real=True) 
                 theta_k = sym.Symbol(f"theta_{bus_k_name}", real=True) 
                 g[2*j]   += V_j*V_k*(G[j,k]*cos(theta_j - theta_k) + B[j,k]*sin(theta_j - theta_k)) 
                 g[2*j+1] += V_j*V_k*(G[j,k]*sin(theta_j - theta_k) - B[j,k]*cos(theta_j - theta_k))        
-                h_grid.update({f"V_{bus_j_name}":V_j})
+                self.dae['h_dict'].update({f"V_{bus_j_name}":V_j})
             bus = self.buses[j]
             bus_name = bus['name']
             if 'type' in bus:
                 if bus['type'] == 'slack':
-                    y_grid += [P_j]
-                    y_grid += [Q_j]
-                    u_grid.update({f"V_{bus_name}":1.0})
-                    u_grid.update({f"theta_{bus_name}":0.0})  
+                    self.dae['y_ini'] += [P_j]
+                    self.dae['y_ini'] += [Q_j]
+                    self.dae['y_run'] += [P_j]
+                    self.dae['y_run'] += [Q_j]
+                    self.dae['u_ini_dict'].update({f"V_{bus_name}":1.0})
+                    self.dae['u_ini_dict'].update({f"theta_{bus_name}":0.0})  
+                    self.dae['u_run_dict'].update({f"V_{bus_name}":1.0})
+                    self.dae['u_run_dict'].update({f"theta_{bus_name}":0.0})  
             else:
-                y_grid += [V_j]
-                y_grid += [theta_j]        
-                u_grid.update({f"P_{bus_name}":bus['P_W']})
-                u_grid.update({f"Q_{bus_name}":bus['Q_var']})    
-                xy_0_dict_grid.update({str(V_j):1.0,str(theta_j):0.0})
+                self.dae['y_ini'] += [V_j]
+                self.dae['y_ini'] += [theta_j]     
+                self.dae['y_run'] += [V_j]
+                self.dae['y_run'] += [theta_j]       
+                self.dae['u_ini_dict'].update({f"P_{bus_name}":bus['P_W']})
+                self.dae['u_ini_dict'].update({f"Q_{bus_name}":bus['Q_var']})    
+                self.dae['u_run_dict'].update({f"P_{bus_name}":bus['P_W']})
+                self.dae['u_run_dict'].update({f"Q_{bus_name}":bus['Q_var']})  
+                self.dae['xy_0_dict'].update({str(V_j):1.0,str(theta_j):0.0})
                 
-            self.params_grid.update({f'U_{bus_name}_n':bus['U_kV']*1000})
-        g_grid = list(g)     
+            self.dae['params_dict'].update({f'U_{bus_name}_n':bus['U_kV']*1000})
+        self.dae['g'] += list(g)     
     
         if False:
             v_sym_list = []
-            for bus in buses_list:
+            for bus in self.buses_list:
                 V_m = sym.Symbol(f'V_{bus}',real=True)
                 V_a = sym.Symbol(f'theta_{bus}',real=True)
                 v_sym_list += [V_m*sym.exp(sym.I*V_a)]
@@ -352,16 +359,19 @@ class bmapu:
     
             I_lines = (G_primitive+1j*B_primitive) * A * sym.Matrix(v_sym_list)
     
-            it = 0
+            self.it = 0
             for line in self.lines:
                 I_jk_r = sym.Symbol(f"I_{line['bus_j']}_{line['bus_k']}_r", real=True)
                 I_jk_i = sym.Symbol(f"I_{line['bus_j']}_{line['bus_k']}_i", real=True)
-                g_grid += [-I_jk_r + sym.re(I_lines[it])]
-                g_grid += [-I_jk_i + sym.im(I_lines[it])]
-                y_grid += [I_jk_r]
-                y_grid += [I_jk_i]
-                it += 1
+                self.dae['g'] += [-I_jk_r + sym.re(I_lines[self.it])]
+                self.dae['g'] += [-I_jk_i + sym.im(I_lines[self.it])]
+                self.dae['y_ini'] += [I_jk_r]
+                self.dae['y_ini'] += [I_jk_i]
+                self.dae['y_run'] += [I_jk_r]
+                self.dae['y_run'] += [I_jk_i]
+                self.it += 1
         
+        ### Lines monitoring
         for line in self.lines:
     
             bus_j = line['bus_j']
@@ -369,8 +379,8 @@ class bmapu:
 
             line_name = f"{bus_j}_{bus_k}"
     
-            idx_j = buses_list.index(bus_j)
-            idx_k = buses_list.index(bus_k)  
+            idx_j = self.buses_list.index(bus_j)
+            idx_k = self.buses_list.index(bus_k)  
 
             V_j = sym.Symbol(f"V_{bus_j}", real=True) 
             V_k = sym.Symbol(f"V_{bus_k}", real=True) 
@@ -378,70 +388,92 @@ class bmapu:
             theta_k = sym.Symbol(f"theta_{bus_k}", real=True)
 
             b_ij_p = 0.0
-            if f'bs_{line_name}' in self.params_grid:
-                b_ij_p = self.params_grid[f'bs_{line_name}']
-
-            G_jk = G[idx_j,idx_k] 
-            B_jk = B[idx_j,idx_k] 
-            theta_jk = theta_j - theta_k
-            P_line_to   = V_j*V_k*(G_jk*sym.cos(theta_jk) + B_jk*sym.sin(theta_jk)) - V_j**2*(G_jk) 
-            Q_line_to   = V_j*V_k*(G_jk*sym.sin(theta_jk) - B_jk*sym.cos(theta_jk)) + V_j**2*(B_jk) 
-            P_line_from = V_j*V_k*(G_jk*sym.cos(-theta_jk) + B_jk*sym.sin(-theta_jk)) - V_k**2*(G_jk) 
-            Q_line_from = V_j*V_k*(G_jk*sym.sin(-theta_jk) - B_jk*sym.cos(-theta_jk)) + V_k**2*(B_jk) 
-
-            if 'monitor' in line:
-                if line['monitor']:
-                    # h_grid.update({f"p_line_{bus_j}_{bus_k}":P_line_to})
-                    # h_grid.update({f"q_line_{bus_j}_{bus_k}":Q_line_to}) 
-                    # h_grid.update({f"p_line_{bus_k}_{bus_j}":P_line_from})
-                    # h_grid.update({f"q_line_{bus_k}_{bus_j}":Q_line_from}) 
+            if f'bs_{line_name}' in self.dae['params_dict']:
+                b_ij_p = self.dae['params_dict'][f'bs_{line_name}']
+
+
+
+            if 'monitor' in line or 'dtr' in line:
+                if line['monitor'] or line['dtr']:
+                    # self.dae['h_dict'].update({f"p_line_{bus_j}_{bus_k}":P_line_to})
+                    # self.dae['h_dict'].update({f"q_line_{bus_j}_{bus_k}":Q_line_to}) 
+                    # self.dae['h_dict'].update({f"p_line_{bus_k}_{bus_j}":P_line_from})
+                    # self.dae['h_dict'].update({f"q_line_{bus_k}_{bus_j}":Q_line_from}) 
+
+
+                    G_jk = G[idx_j,idx_k] 
+                    B_jk = B[idx_j,idx_k] 
+                    theta_jk = theta_j - theta_k
+                    P_line_to   = V_j*V_k*(G_jk*sym.cos(theta_jk) + B_jk*sym.sin(theta_jk)) - V_j**2*(G_jk) 
+                    Q_line_to   = V_j*V_k*(G_jk*sym.sin(theta_jk) - B_jk*sym.cos(theta_jk)) + V_j**2*(B_jk) 
+                    P_line_from = V_j*V_k*(G_jk*sym.cos(-theta_jk) + B_jk*sym.sin(-theta_jk)) - V_k**2*(G_jk) 
+                    Q_line_from = V_j*V_k*(G_jk*sym.sin(-theta_jk) - B_jk*sym.cos(-theta_jk)) + V_k**2*(B_jk) 
+
                     p_line_to_pu,q_line_to_pu = sym.symbols(f"p_line_pu_{bus_j}_{bus_k},q_line_pu_{bus_j}_{bus_k}", real=True)
                     p_line_from_pu,q_line_from_pu = sym.symbols(f"p_line_pu_{bus_k}_{bus_j},q_line_pu_{bus_k}_{bus_j}", real=True)
 
-                    g_grid += [p_line_to_pu - P_line_to]
-                    g_grid += [q_line_to_pu - Q_line_to]
-                    g_grid += [p_line_from_pu - P_line_from]
-                    g_grid += [q_line_from_pu - Q_line_from]
+                    self.dae['g'] += [p_line_to_pu - P_line_to]
+                    self.dae['g'] += [q_line_to_pu - Q_line_to]
+                    self.dae['g'] += [p_line_from_pu - P_line_from]
+                    self.dae['g'] += [q_line_from_pu - Q_line_from]
 
-                    y_grid += [p_line_to_pu,q_line_to_pu,p_line_from_pu,q_line_from_pu]
+                    self.dae['y_ini'] += [p_line_to_pu,q_line_to_pu,p_line_from_pu,q_line_from_pu]
+                    self.dae['y_run'] += [p_line_to_pu,q_line_to_pu,p_line_from_pu,q_line_from_pu]
                     
                     U_base = self.buses[idx_j]['U_kV']*1000
                     I_base = S_base/(np.sqrt(3)*U_base)
 
-                    h_grid.update({f'p_line_{bus_j}_{bus_k}':p_line_to_pu*S_base})
-                    h_grid.update({f'q_line_{bus_j}_{bus_k}':q_line_to_pu*S_base})
-                    h_grid.update({f'p_line_{bus_k}_{bus_j}':p_line_from_pu*S_base})
-                    h_grid.update({f'q_line_{bus_k}_{bus_j}':q_line_from_pu*S_base})
+                    self.dae['h_dict'].update({f'p_line_{bus_j}_{bus_k}':p_line_to_pu*S_base})
+                    self.dae['h_dict'].update({f'q_line_{bus_j}_{bus_k}':q_line_to_pu*S_base})
+                    self.dae['h_dict'].update({f'p_line_{bus_k}_{bus_j}':p_line_from_pu*S_base})
+                    self.dae['h_dict'].update({f'q_line_{bus_k}_{bus_j}':q_line_from_pu*S_base})
+
+                    I_j_k,I_k_j = sym.symbols(f"I_{bus_j}_{bus_k},I_{bus_k}_{bus_j}", real=True)
 
-                    I_j_k_pu = (  p_line_to_pu**2 +   q_line_to_pu**2)**0.5/V_j
-                    I_k_j_pu = (p_line_from_pu**2 + q_line_from_pu**2)**0.5/V_k
+                    I_j_k_eq = (  p_line_to_pu**2 +   q_line_to_pu**2)**0.5/V_j*I_base
+                    I_k_j_eq = (p_line_from_pu**2 + q_line_from_pu**2)**0.5/V_k*I_base
 
-                    h_grid.update({f'I_line_{bus_j}_{bus_k}':I_j_k_pu*I_base})
-                    h_grid.update({f'I_line_{bus_k}_{bus_j}':I_k_j_pu*I_base})
+                    self.dae['g'] += [I_j_k_eq - I_j_k]
+
+                    self.dae['y_ini'] += [I_j_k]
+                    self.dae['y_run'] += [I_j_k]
+
+
+                    self.dae['g'] += [I_k_j_eq - I_k_j]
+
+                    self.dae['y_ini'] += [I_k_j]
+                    self.dae['y_run'] += [I_k_j]
+
+                    self.dae['h_dict'].update({f'I_line_{bus_j}_{bus_k}':I_j_k})
+                    self.dae['h_dict'].update({f'I_line_{bus_k}_{bus_j}':I_k_j})
+
+                    self.dae['xy_0_dict'].update({str(p_line_to_pu):0.1})  
+                    self.dae['xy_0_dict'].update({str(p_line_from_pu):-0.1})  
+                    self.dae['xy_0_dict'].update({str(I_j_k):0.1})  
+                    self.dae['xy_0_dict'].update({str(I_k_j):-0.1})  
 
         for bus in self.buses:
             if 'monitor' in bus:
                 if bus['monitor']:
                     U_base = bus['U_kV']*1000
                     V = sym.Symbol(f"V_{bus['name']}", real=True) 
-                    h_grid.update({f"U_{bus['name']}":V*U_base})
+                    self.dae['h_dict'].update({f"U_{bus['name']}":V*U_base})
  
 
 
-        self.dae['f'] += []
-        self.dae['g'] += g_grid
-        self.dae['x'] += []
-        self.dae['y_ini'] += y_grid
-        self.dae['y_run'] += y_grid
-        self.dae['u_ini_dict'].update(u_grid)
-        self.dae['u_run_dict'].update(u_grid)
-        self.dae['h_dict'].update(h_grid)
-        self.dae['params_dict'].update(self.params_grid)
-        self.dae['xy_0_dict'].update(xy_0_dict_grid)
-        
-        self.A_incidence = A
-        self.G_primitive = G_primitive
-        self.B_primitive = B_primitive
+        # self.dae['f'] += []
+        #self.dae['g'] += g_grid
+        # self.dae['x'] += []
+        # self.dae['y_ini'] += self.dae['y_ini']
+        # self.dae['y_run'] += self.dae['y_ini']
+        # self.dae['u_ini_dict'].update(self.dae['u_ini_dict'])
+        # self.dae['u_run_dict'].update(self.dae['u_ini_dict'])
+        # self.dae['h_dict'].update(self.dae['h_dict'])
+        # self.dae['params_dict'].update(self.dae['params_dict'])
+
+        self.A_incidence = self.A
+        self.G_primitive = self.G_primitive
+        self.B_primitive = self.B_primitive
 
 
         self.N_syn = 0
@@ -639,7 +671,7 @@ class bmapu:
 if __name__ == "__main__":
 
     data = {
-        "sys":{"name":"k12p6","S_base":100e6, "K_p_agc":0.01,"K_i_agc":0.01},       
+        "system":{"name":"k12p6","S_base":100e6, "K_p_agc":0.01,"K_i_agc":0.01},       
         "buses":[{"name":"1", "P_W":0.0,"Q_var":0.0,"U_kV":20.0},
                  {"name":"2", "P_W":0.0,"Q_var":0.0,"U_kV":20.0}],
         "lines":[{"bus_j":"1", "bus_k":"2", "X_pu":0.15,"R_pu":0.0, "S_mva":900.0}]