pydae 0.56.4__py3-none-any.whl → 0.57__py3-none-any.whl

pydae/bmapu/lines/lib_dtr.py

@@ -0,0 +1,425 @@
+# Importing required libraries
+import numpy as np
+from scipy.optimize import fsolve, minimize, NonlinearConstraint
+
+
+
+class grid:
+    def __init__(self, nodes, lines, pros):
+        self.nodes = self.add_nodes(nodes)                                      
+        self.lines = self.add_lines(lines, self.nodes)  
+        self.pros = self.add_pros(pros, self.nodes)  
+        self.pf = pf(self)
+        self.ofo = ofo(self)
+        self.opf = opf(self)
+                
+    def add_nodes(self, nodes):
+        nodes_list = list()
+        for item in nodes:
+            nodes_list.append(node(item['id'], item['slack']))
+        return nodes_list
+        
+    def add_lines(self, lines, nodes):
+        lines_list = list()
+        for item in lines:
+            lines_list.append(line(item['id'], item['From'], item['To'], item['R'], item['X'], nodes))
+        return lines_list
+        
+    def add_pros(self, pros, nodes):
+        pros_list = list()
+        for item in pros:
+            pros_list.append(prosumer(item['id'], item['Node'], item['P'], item['Q'], nodes))
+        return pros_list
+
+
+class opf:
+    def __init__(self, net):
+        self.net = net
+                
+    def set_params(self, params):
+        self.inputs, self.outputs = [], []
+        for item in params:
+            if item['type'] == 'input':
+                name = 'ofo-' + item['type'] + '-' + item['signal'] + '-' + item['element'] + '-' + str(item['node'])
+                self.inputs.append((name, item['bounds']))
+                self.net.pros.append(prosumer(name, item['node'], 0, 0, self.net.nodes))
+                self.net.pros[-1].bnds = item['bounds']
+            if item['type'] == 'output':
+                name = 'ofo-' + item['type'] + '-' + item['signal'] + '-' + item['element'] + '-' + str(item[item['element']])
+                self.outputs.append((name, item['bounds']))
+        self.n_in = len(self.inputs)
+        self.n_out = len(self.outputs)
+    
+    def set_inputs(self, inputs):
+        in_base = self.get_inputs()
+        for k, v in zip(in_base.keys(), inputs):
+            in_base[k] = v
+        for in_item in in_base:
+            _, _, mag, elem, ref = in_item.split('-') 
+            pro = next((item for item in self.net.pros if item.ref == in_item), None)
+            setattr(pro, mag, in_base[in_item])
+        
+    def get_inputs(self):
+        in_base = {item[0]: 0 for item in self.inputs}
+        self.net.pf.solve_pf()
+        for in_item in in_base:
+            _, _, mag, elem, ref = in_item.split('-') 
+            pro = next((item for item in self.net.pros if item.ref == in_item), None)
+            in_base[in_item] = getattr(pro, mag)
+        return in_base
+        
+    
+    def get_outputs(self):
+        self.output_data = []
+        for item in [output[0] for output in self.outputs]:
+            _, _, mag, elem, ref = item.split('-') 
+            if elem == 'node':
+                self.output_data.append(np.abs(getattr(self.net.nodes[int(ref)], mag)))
+            if elem == 'line':
+                self.output_data.append(np.abs(getattr(self.net.lines[int(ref)], mag)))
+        return self.output_data
+    
+    def obj_function(self, x):
+        self.set_inputs(x)
+        self.net.pf.solve_pf()
+        y = self.get_outputs()
+        return self.f_u @ x + self.f_y @ y 
+    
+    def y_constraints(self, x):
+        self.set_inputs(x)
+        self.net.pf.solve_pf()
+        y = self.get_outputs()
+        return self.C @ y - self.d
+    
+    def solve_opf(self, obj):
+        self.C = np.block([[ np.eye(self.n_out)],
+                           [-np.eye(self.n_out)]])
+        self.d = np.array([item[1][1] for item in self.outputs] + [-item[1][0] for item in self.outputs])
+        self.f_u, self.f_y = obj          
+        y_constr = NonlinearConstraint(self.y_constraints, -np.inf, 0)
+        sol = minimize(self.obj_function, 
+                       np.array(list(self.get_inputs().values())), 
+                       bounds=[(item[1][0], item[1][1]) for item in self.inputs],
+                       constraints=(y_constr,))
+        print(f'OPF success: {sol.success}, obj: {sol.fun}\n')
+        return sol
+        
+        
+        
+        
+        
+
+class ofo:
+    def __init__(self, net):
+        self.net = net
+        
+    def set_params(self, params):
+        self.inputs, self.outputs = [], []
+        for item in params:
+            if item['type'] == 'input':
+                name = 'ofo-' + item['type'] + '-' + item['signal'] + '-' + item['element'] + '-' + str(item['node'])
+                self.inputs.append((name, item['bounds']))
+                self.net.pros.append(prosumer(name, item['node'], 0, 0, self.net.nodes))
+                self.net.pros[-1].bnds = item['bounds']
+            if item['type'] == 'output':
+                name = 'ofo-' + item['type'] + '-' + item['signal'] + '-' + item['element'] + '-' + str(item[item['element']])
+                self.outputs.append((name, item['bounds']))
+        self.n_in = len(self.inputs)
+        self.n_out = len(self.outputs)
+    
+    def reset(self):
+        u = self.get_inputs()
+        for k, v in zip(u.keys(), np.zeros(len(u))):
+            u[k] = v
+        self.set_inputs(u)
+        self.net.pf.solve_pf()
+        y = self.get_outputs()
+    
+    def set_inputs(self, inputs):
+        for in_item in inputs:
+            if len(in_item) == 2:
+                _, _, mag, elem, ref = in_item[0].split('-') 
+                pro = next((item for item in self.net.pros if item.ref == in_item[0]), None)
+                setattr(pro, mag, inputs[in_item])
+            else:
+                _, _, mag, elem, ref = in_item.split('-') 
+                pro = next((item for item in self.net.pros if item.ref == in_item), None)
+                setattr(pro, mag, inputs[in_item])
+        
+    def get_inputs(self):
+        in_base = {item[0]: 0 for item in self.inputs}
+        self.net.pf.solve_pf()
+        for in_item in in_base:
+            _, _, mag, elem, ref = in_item.split('-') 
+            pro = next((item for item in self.net.pros if item.ref == in_item), None)
+            in_base[in_item] = getattr(pro, mag)
+        return in_base
+        
+    
+    def get_outputs(self):
+        self.output_data = []
+        for item in [output[0] for output in self.outputs]:
+            _, _, mag, elem, ref = item.split('-') 
+            if elem == 'node':
+                self.output_data.append(np.abs(getattr(self.net.nodes[int(ref)], mag)))
+            if elem == 'line':
+                self.output_data.append(np.abs(getattr(self.net.lines[int(ref)], mag)))
+        return self.output_data
+            
+    
+    def compute_H(self):
+        self.net.pf.solve_pf()
+        self.H = np.zeros((self.n_out, self.n_in))
+        in_base = self.get_inputs()
+        for idx in range(self.n_in):
+            self.H[:, idx] = self.get_outputs()
+        for idx, key in enumerate(in_base):
+            in_base[key] += 1
+            self.set_inputs(in_base)
+            self.net.pf.solve_pf()
+            self.H[:, idx] = - self.H[:, idx] + self.get_outputs()
+            in_base[key] -= 1        
+        self.set_inputs(in_base)
+        self.net.pf.solve_pf()
+          
+    def solve_ofo(self, obj, alpha = 0.01, rho = 1, max_iter = 10):
+        self.reset()
+        self.compute_H()
+        self.C = np.block([[ np.eye(self.n_out)],
+                           [-np.eye(self.n_out)]])
+        self.d = np.array([item[1][1] for item in self.outputs] + [-item[1][0] for item in self.outputs])
+        self.mu = np.zeros(self.C.shape[0])
+        self.s = np.zeros(self.C.shape[0])
+        self.f_u, self.f_y = obj          
+        self.in_bnds = [(item[1][0], item[1][1]) for item in self.inputs] 
+                    
+        # Data aquisition
+        hist = {'u_h': [], 'y_h': [], 'loss_h': [], 'of_h': [], 'mu_h': [], 'H_h': []}
+        actual_inputs = np.array(list(self.get_inputs().values()))
+        actual_outputs = np.array(self.get_outputs())
+        
+        for it in range(max_iter):
+            # Verbose
+            print(f'Iteration {it}')
+            
+            # Updating slack variables
+            self.s = np.clip((-(1/rho)*self.mu - self.C @ actual_outputs + self.d), a_min = 0, a_max=None)
+            
+            # Updating primal variables
+            delta_u = self.f_u + self.H.T @ self.f_y + \
+                self.H.T @ self.C.T @ (self.mu + rho*(self.C @ actual_outputs + self.s - self.d))
+            actual_inputs = actual_inputs - alpha*delta_u
+            actual_inputs = np.clip(actual_inputs, a_min = [bnds[0] for bnds in self.in_bnds], a_max = [bnds[1] for bnds in self.in_bnds])
+            actual_inputs_dict = self.get_inputs()
+            for k, v in zip(actual_inputs_dict.keys(), actual_inputs):
+                actual_inputs_dict[k] = v
+            self.set_inputs(actual_inputs_dict)       
+                                    
+            # Solving power flow and receiving outputs
+            self.net.pf.solve_pf()
+            actual_outputs = np.array(self.get_outputs())
+            
+            # Updating sensitivity martix
+            self.compute_H()
+                        
+            # Updating dual variables
+            self.mu += rho*(self.C @ actual_outputs - self.d + self.s)
+            
+            # Saving data    
+            hist['u_h'].append(actual_inputs.copy())
+            hist['y_h'].append(actual_outputs.copy())
+            hist['mu_h'].append(self.mu.copy())
+            hist['H_h'].append(self.H.copy())
+          
+        print(f'OFO final value: {self.f_u @ actual_inputs + self.f_y @ actual_outputs}\n')
+        return hist
+
+class pf:
+    def __init__(self, net):
+        self.net = net
+
+    def solve_pf(self, verbose = False):
+        x0 = [1,0]*len(self.net.nodes)
+        sol, infodict, ier, mesg = fsolve(self.test_x, x0, full_output = True)
+        if verbose:
+            print(mesg)
+        index = 0
+        for node in self.net.nodes:
+            node.U = complex(sol[index], sol[index+1])
+            index += 2
+        for line in self.net.lines:
+            line.compute_I()
+        for line in self.net.lines:
+            line.compute_PQ()
+        return sol, infodict, ier, mesg
+    
+    def compute_res(self):
+        residual = []
+        for node in self.net.nodes:
+            residual.append(node.check())
+        residual_rx = []
+        for item in residual:
+            residual_rx.append(np.real(item))
+            residual_rx.append(np.imag(item))
+        return residual_rx
+    
+    def test_x(self, x):
+        self.assign_x(x)
+        self.compute_I()
+        res = self.compute_res()
+        return res    
+    
+    def assign_x(self, x):
+        index = 0
+        for node in self.net.nodes:
+            node.U = complex(x[index], x[index + 1])
+            index += 2   
+            
+    def compute_I(self):
+        for line in self.net.lines:
+            line.I = (line.nodes[0].U - line.nodes[1].U)/line.Z
+        for node in self.net.nodes: # +: inyeccion, -: demanda
+            node.I = np.conj(np.sum([complex(p.P, p.Q) for p in node.pros])/node.U)
+            
+class node:
+    def __init__(self, ref, slack):
+        self.ref = ref   
+        self.slack = slack        
+        self.lines = list()
+        self.U = complex(1, 0)
+        self.pros = []
+    
+    def check(self):
+        if self.slack:
+            residual = self.U - complex(1, 0)
+        else:
+            I_agregada = 0
+            I_agregada += self.I
+            for line in self.lines:
+                if line.nodes[0] == self:
+                    I_agregada -= line.I
+                else:
+                    I_agregada += line.I
+            residual = I_agregada
+        return residual
+        
+class line:
+    def __init__(self, ref, From, To, R, X, nodes_list):
+        self.ref = ref     
+        self.Z = complex(R, X)
+        self.G, self.B = np.real(1/self.Z), -np.imag(1/self.Z)
+        self.Y = 1/self.Z
+        self.nodes = [next((item for item in nodes_list if item.ref == From), None), 
+                      next((item for item in nodes_list if item.ref == To), None)]   
+        self.nodes[0].lines.append(self)
+        self.nodes[1].lines.append(self)
+        
+    def compute_I(self):
+        self.I = (self.nodes[0].U - self.nodes[1].U)/self.Z
+        
+    def compute_PQ(self):
+        self.P = np.real(self.nodes[0].U*np.conj(self.I))
+        self.Q = np.imag(self.nodes[0].U*np.conj(self.I))
+            
+  
+class prosumer:
+    def __init__(self, ref, node_id, P, Q, nodes_list):
+        self.ref = ref
+        self.P = P
+        self.Q = Q        
+        self.node = next((item for item in nodes_list if item.ref == node_id), None)
+        self.node.pros.append(self)
+        
+        
+class DTR_line:     
+    def __init__(self):
+        self.D = 27.7e-3
+        self.d = 3.08e-3
+        self.sigma  = 5.670373e-8
+        self.epsilon = 0.8
+        self.alpha = 0.8
+        self.Tc_max = 95 
+        self.Rac = 1.04*0.000071873143*(1+0.000937474*(self.Tc_max-20));
+        self.h = 1
+        self.g = 9.81
+    
+    def compute_I(self, Tamb, v_w, ang_w, G):
+        self.Tamb = Tamb
+        self.v_w = v_w
+        self.ang_w = ang_w
+        self.G = G
+        
+        self.compute_Pr()
+        self.compute_Pc()
+        self.compute_Ps()
+        
+        self.I = np.sqrt( (self.Pr + self.Pc - self.Ps)/self.Rac )        
+        return self.I
+        
+    def compute_Pr(self):
+        self.Pr = np.pi*self.D*self.sigma*self.epsilon*((self.Tc_max + 273.15)**4 - (self.Tamb + 273.15)**4)
+        return self.Pr
+        
+    def compute_Pc(self):        
+        Tf = 0.5*(self.Tamb + self.Tc_max)
+        lmb = 2.368e-2 + 7.23e-5*Tf - 2.763e-8*Tf**2
+        cf = 1.9327e-10*Tf**4 - 7.9999e-7*Tf**3 + 1.1407e-3*Tf**2 - 0.4489*Tf + 1057.5
+        Rs = self.d / (2*(self.D - self.d))
+        
+        mu_f = (17.239 + 4.635e-2*Tf - 2.03e-5*Tf**2) * 1e-6
+        dens = (1.293 - 1.525e-4*self.h + 6.379e-9*self.h**2) / (1 + 0.00367*Tf)
+        uf = mu_f / dens  
+        Re = self.v_w * self.D / uf
+
+        B, n = (0.178, 0.633) if (Re > 2650 and Rs <= 0.05) else ((0.048, 0.8) if Re > 2650 else (0.641, 0.471))
+        Nu90 = B * Re**n
+
+        angle = self.ang_w if self.ang_w <= 180 else self.ang_w - 180
+        seno = np.abs(np.sin(np.radians(angle)))
+        delta = 0.42 + (0.68 * seno**1.08 if angle <= 24 else 0.58 * seno**0.9)
+        Nu_forz = Nu90 * delta
+        
+        Gr = self.D**3 * (self.Tc_max - self.Tamb) * self.g / ((Tf + 273.15) * uf**2)
+        Pr = cf * mu_f / lmb
+        prod = Gr * Pr
+
+        if 0.1 < prod < 1e2:
+            A, m = 1.02, 0.148
+        elif 1e2 <= prod < 1e4:
+            A, m = 0.85, 0.188
+        elif 1e4 <= prod < 1e7:
+            A, m = 0.48, 0.25
+        elif 1e7 <= prod < 1e12:
+            A, m = 0.125, 0.333
+        else:
+            A, m = 0, 0
+        Nu_nat = A * prod**m
+
+        Nu = np.max([Nu_nat, Nu_forz])
+
+        self.Pc = np.pi * lmb * (self.Tc_max - self.Tamb) * Nu
+        return self.Pc
+    
+    def compute_Ps(self):
+        self.Ps = self.alpha*self.G*self.D
+        return self.Ps
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+    

pydae/bmapu/lines/lines.py

@@ -6,6 +6,154 @@ Created on Thu August 10 23:52:55 2022
 """
 
 import numpy as np
+import sympy as sym
+
+
+def add_lines(self):
+
+    self.g_line_monitors = []
+    self.y_line_monitors = []
+            
+    for line in self.lines:
+
+        it = self.it 
+
+        bus_j = line['bus_j']
+        bus_k = line['bus_k']
+
+        idx_j = self.buses_list.index(bus_j)
+        idx_k = self.buses_list.index(bus_k)    
+
+        self.A[it,idx_j] = 1
+        self.A[it,idx_k] =-1   
+        self.A[it+1,idx_j] = 1
+        self.A[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) 
+        self.G_primitive[it,it] = g_jk
+        self.B_primitive[it,it] = b_jk
+        self.B_primitive[it+1,it+1] = bs_jk/2
+        self.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']*self.sys['S_base']/S_line  # in pu of the system base
+            X = line['X_pu']*self.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})
+
+        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/self.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_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/self.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.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})        
+
+        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/self.sys['S_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/self.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
+            
+        it += 3
+
+        if 'monitor' in line:
+            if line['monitor']:
+
+                bus_j = line['bus_j']
+                bus_k = line['bus_k']
+
+                line_name = f"{bus_j}_{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) 
+                theta_j = sym.Symbol(f"theta_{bus_j}", real=True) 
+                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_jk
+                B_jk = b_jk
+                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) + V_j**2*(bs_jk/2)
+                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) + V_k**2*(bs_jk/2)
+
+
+                # 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}) 
+                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)
+
+                self.g_line_monitors += [p_line_to_pu - P_line_to]
+                self.g_line_monitors += [q_line_to_pu - Q_line_to]
+                self.g_line_monitors += [p_line_from_pu - P_line_from]
+                self.g_line_monitors += [q_line_from_pu - Q_line_from]
+
+                self.y_line_monitors += [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 = self.S_base/(np.sqrt(3)*U_base)
+
+                self.h_grid.update({f'p_line_{bus_j}_{bus_k}':p_line_to_pu*self.S_base})
+                self.h_grid.update({f'q_line_{bus_j}_{bus_k}':q_line_to_pu*self.S_base})
+                self.h_grid.update({f'p_line_{bus_k}_{bus_j}':p_line_from_pu*self.S_base})
+                self.h_grid.update({f'q_line_{bus_k}_{bus_j}':q_line_from_pu*self.S_base})
+
+                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
+
+                self.h_grid.update({f'I_line_{bus_j}_{bus_k}':I_j_k_pu*I_base})
+                self.h_grid.update({f'I_line_{bus_k}_{bus_j}':I_k_j_pu*I_base})
+
+
 
 def change_line(model,bus_j,bus_k, *args,**kwagrs):
     line = kwagrs
@@ -62,4 +210,92 @@ def get_line_current(model,bus_j,bus_k, units='A'):
         I_b = S_b/(np.sqrt(3)*U_b)
         I_j_k = I_j_k_pu*I_b
 
-    return I_j_k
+    return I_j_k
+
+
+def test_line_pu_build():
+    
+    from pydae.bmapu import bmapu_builder
+    from pydae.build_v2 import build_mkl,build_numba
+
+    data = {
+        "system":{"name":"temp","S_base":100e6, "K_p_agc":0.01,"K_i_agc":0.01, "K_xif":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,"Bs_pu":0.5, "S_mva":900.0, "monitor":True}],
+        "sources":[{"bus":"1","type":"vsource","V_mag_pu":1.0,"V_ang_rad":0.0,"K_delta":0.1}]
+        }
+
+    grid = bmapu_builder.bmapu(data)
+    grid.uz_jacs = False
+    grid.verbose = True
+    grid.construct(f'temp')
+    build_numba(grid.sys_dict)
+
+def test_line_pu_ini():
+    
+    import temp
+
+    model = temp.model()
+    model.ini({'P_2':0e6, "K_xif":0.01},'xy_0.json')
+    print(f"V_1 = {model.get_value('V_1'):2.2f}, V_2 = {model.get_value('V_2'):2.2f}")
+
+    model.report_y()
+
+def test_line_km_build():
+    
+    from pydae.bmapu import bmapu_builder
+    from pydae.build_v2 import build_mkl,build_numba
+
+    R_km = 0.0268  # (Ω/km)
+    X_km = 0.2766  # (Ω/km)
+    B_km = 4.59e-6 # (℧-1/Km)
+
+    N_parallel = 44.0
+
+    Lenght_km = 22000.0/N_parallel
+
+    data = {
+        "system":{"name":"temp","S_base":100e6, "K_p_agc":0.01,"K_i_agc":0.01, "K_xif":0.01},       
+        "buses":[{"name":"1", "P_W":0.0,"Q_var":0.0,"U_kV":400.0},
+                 {"name":"2", "P_W":5000e6,"Q_var":0.0,"U_kV":400.0}],
+        "lines":[{"bus_j":"1", "bus_k":"2", 'X_km':X_km/44, 'R_km':R_km/44, 'Bs_km':B_km*44, "km":Lenght_km, "monitor":True}],
+        "sources":[{"bus":"1","type":"vsource","V_mag_pu":1.0,"V_ang_rad":0.0,"K_delta":0.1}]
+        }
+
+    grid = bmapu_builder.bmapu(data)
+    grid.uz_jacs = False
+    grid.verbose = True
+    grid.construct(f'temp')
+    build_numba(grid.sys_dict)
+
+def test_line_km_ini():
+    
+    import temp
+
+    model = temp.model()
+    model.ini({'P_2':5000e6,'Q_2':0, "K_xif":0.01},'xy_0.json')
+    print(f"V_1 = {model.get_value('V_1'):2.2f}, V_2 = {model.get_value('V_2'):2.2f}")
+
+    print("report_y:")
+    model.report_y()
+    print("-----------------------------------------------------------------------")
+    print("report_z:")
+    model.report_z()
+
+    U_1 = 400e3
+    U_2 = 400e3 
+    Bs = 4.59e-6*22000
+    Q = U_1**2*Bs/2 + U_2**2*Bs/2
+    print(f"Q = {Q/1e6:2.2f} Mvar")
+
+
+if __name__ == "__main__":
+
+    #test_line_pu_build()
+    #test_line_pu_ini()
+
+    test_line_km_build()
+    test_line_km_ini()
+
+