def __init__(self, agent_id_to_grid_id, fname='Grid.xlsx', dt=1): self.current_transactions = Transactions() self.chain = [] self.nodes = set() self.agent_id_to_grid_id = agent_id_to_grid_id self.actors_group = ActorsGroup() self.market = Market(actors_group=self.actors_group) self.dt = dt self.grid = MultiCircuit() self.grid.load_file(fname) # Create the genesis block self.new_block(previous_hash='1', proof=100)
def __init__(self, grid: MultiCircuit, verbose=False): self.grid = grid self.problem = AcOPFBlackBox(grid, verbose=verbose) self.numerical_circuit = self.problem.numerical_circuit self.converged = False self.result = None self.load_shedding = np.zeros(len(grid.get_load_names()))
def get_connectivity(file_name): circuit = MultiCircuit() circuit.load_file(file_name) circuit.compile() # form C threshold = 1e-5 m = len(circuit.branches) n = len(circuit.buses) C = lil_matrix((m, n), dtype=int) buses_dict = {bus: i for i, bus in enumerate(circuit.buses)} branches_to_keep_idx = list() branches_to_remove_idx = list() states = np.zeros(m, dtype=int) br_idx = [None] * m graph = Graph() for i in range(len(circuit.branches)): # get the from and to bus indices f = buses_dict[circuit.branches[i].bus_from] t = buses_dict[circuit.branches[i].bus_to] graph.add_edge(f, t) C[i, f] = 1 C[i, t] = -1 br_idx[i] = i rx = circuit.branches[i].R + circuit.branches[i].X if circuit.branches[i].branch_type == BranchType.Branch: branches_to_remove_idx.append(i) states[i] = 0 else: branches_to_keep_idx.append(i) states[i] = 1 C = csc_matrix(C) return circuit, states, C, C.transpose() * C, graph
def load_dpx(file_name, contraction_factor=1000): """ Read DPX file :param file_name: file name :return: MultiCircuit """ circuit = MultiCircuit() Sbase = 100 circuit.Sbase = Sbase SQRT3 = np.sqrt(3) # read the raw data into a structured dictionary print('Reading file...') structures_dict, logger = read_dpx_data(file_name=file_name) # format the read data print('Packing data...') data_structures, logger = repack(data_structures=structures_dict, logger=logger) buses_id_dict = dict() # create nodes for tpe in data_structures['Nodes']: # Airline support post # __headers__['Nodes']['APOIO'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST'] # __headers__['Nodes']['ARM'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'YEAR'] # __headers__['Nodes']['CX'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST'] # __headers__['Nodes']['CXN'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST'] # __headers__['Nodes']['LOAD'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'VMIN', 'VMAX', 'NCMPLAN'] # fill to fit... if tpe in ['APOIO', 'ARM', 'CX', 'CXN', 'LOAD']: df = data_structures['Nodes'][tpe] for i in range(df.shape[0]): name = 'B' + str(len(circuit.buses) + 1) + '_' + str( df['NAME'].values[i]) Vnom = float(df['VBASE'].values[i]) x = float(df['GX'].values[i]) / contraction_factor y = float(df['GY'].values[i]) / contraction_factor id_ = df['ID'].values[i] bus = Bus(name=name, vnom=Vnom, xpos=x, ypos=y, height=40, width=60) circuit.add_bus(bus) buses_id_dict[id_] = bus # Network Equivalent # __headers__['Nodes']['EQUIV'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'VMIN', 'VMAX', 'ZONE', # 'SEPNET', 'AUTOUP', 'P', 'Q', 'ELAST', 'SIMUL', 'HTYP', 'HARM5', 'HARM7', # 'HARM11', # 'HARM13', 'NOGRW', 'RS', 'XS', 'R1', 'X1', 'R2', 'X2', 'RH', 'XH', 'COM'] elif tpe == 'EQUIV': df = data_structures['Nodes'][tpe] for i in range(df.shape[0]): name = 'B' + str(len(circuit.buses) + 1) + '_' + str( df['NAME'].values[i]) Vnom = float(df['VBASE'].values[i]) x = float(df['GX'].values[i]) / contraction_factor y = float(df['GY'].values[i]) / contraction_factor id_ = df['ID'].values[i] bus = Bus(name=name, vnom=Vnom, xpos=x, ypos=y, height=40, width=60, is_slack=True) circuit.add_bus(bus) buses_id_dict[id_] = bus name = 'LD' + str(len(circuit.buses)) + '_' + str( df['NAME'].values[i]) p = float(df['P'].values[i]) * Sbase q = float(df['Q'].values[i]) * Sbase load = Load(name=name, power=complex(p, q)) circuit.add_load(bus, load) # Generator # __headers__['Nodes']['GEN'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'MODEL', 'VMIN', # 'VMAX', # 'V', 'ENAB', 'P', 'Q', 'QMIN', 'QMAX', 'ELAST', 'HTYP', 'HARM5', 'HARM7', # 'HARM11', # 'HARM13', 'VNOM', 'RAT', 'TGEN', 'COST', 'YEAR'] elif tpe == 'GEN': df = data_structures['Nodes'][tpe] for i in range(df.shape[0]): name = 'B' + str(len(circuit.buses) + 1) + '_' + str( df['NAME'].values[i]) Vnom = float(df['VBASE'].values[i]) x = float(df['GX'].values[i]) / contraction_factor y = float(df['GY'].values[i]) / contraction_factor id_ = df['ID'].values[i] bus = Bus(name=name, vnom=Vnom, xpos=x, ypos=y, height=40, width=60) circuit.add_bus(bus) buses_id_dict[id_] = bus mode = int(df['MODEL'].values[i]) if mode == 1: name = 'GEN' + str(len(circuit.buses)) + '_' + str( df['NAME'].values[i]) p = float(df['P'].values[i]) * Sbase q = float(df['Q'].values[i]) * Sbase v = float(df['V'].values[i]) # p.u. gen = ControlledGenerator(name=name, active_power=p, voltage_module=v) circuit.add_controlled_generator(bus, gen) else: name = 'GENSTAT' + str(len(circuit.buses)) + '_' + str( df['NAME'].values[i]) p = float(df['P'].values[i]) * Sbase q = float(df['Q'].values[i]) * Sbase gen = StaticGenerator(name=name, power=complex(p, q)) circuit.add_static_generator(bus, gen) # Transformation station # __headers__['Nodes']['PT'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'VMIN', 'VMAX', # 'ZONE', # 'ENAB', 'P', 'Q', 'ELAST', 'SIMUL', 'HTYP', 'HARM5', 'HARM7', 'HARM11', 'HARM13', # 'NOGRW', # 'EQEXIST', 'EQPOSS1', 'MCOST1', 'ICOST1', 'EQPOSS2', 'MCOST2', 'ICOST2', # 'EQPOSS3', 'MCOST3', # 'ICOST3', 'NCLI', 'EQTYPE', 'YEAR', 'COM', 'INFOCOM', 'ID_AUX'] elif tpe in ['PT', 'PTC']: df = data_structures['Nodes'][tpe] for i in range(df.shape[0]): name = 'B' + str(len(circuit.buses) + 1) + '_' + str( df['NAME'].values[i]) Vnom = float(df['VBASE'].values[i]) x = float(df['GX'].values[i]) / contraction_factor y = float(df['GY'].values[i]) / contraction_factor id_ = df['ID'].values[i] bus = Bus(name=name, vnom=Vnom, xpos=x, ypos=y, height=40, width=60) name = 'LD' + str(len(circuit.buses) + 1) + '_' + str( df['NAME'].values[i]) p = float(df['P'].values[i]) * Sbase q = float(df['Q'].values[i]) * Sbase load = Load(name=name, power=complex(p, q)) circuit.add_bus(bus) circuit.add_load(bus, load) buses_id_dict[id_] = bus # Reference node # __headers__['Nodes']['REF'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'VREF', 'RAT', # 'COST', 'TGEN', 'YEAR'] elif tpe == 'REF': df = data_structures['Nodes'][tpe] for i in range(df.shape[0]): name = 'B' + str(len(circuit.buses) + 1) + '_' + str( df['NAME'].values[i]) Vnom = float(df['VBASE'].values[i]) x = float(df['GX'].values[i]) / contraction_factor y = float(df['GY'].values[i]) / contraction_factor id_ = df['ID'].values[i] bus = Bus(name=name, vnom=Vnom, xpos=x, ypos=y, height=40, width=60, is_slack=True) circuit.add_bus(bus) buses_id_dict[id_] = bus # Voltage Transformer # __headers__['Nodes']['TT'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'VMIN', 'VMAX', # 'DISABLE', 'HARM5', 'HARM7', 'HARM11', 'HARM13', 'EQEXIST', 'TAP', 'YEAR', # 'ID_AUX'] elif tpe == 'TT': df = data_structures['Nodes'][tpe] for i in range(df.shape[0]): name = 'B' + str(len(circuit.buses) + 1) + '_' + str( df['NAME'].values[i]) Vnom = float(df['VBASE'].values[i]) x = float(df['GX'].values[i]) / contraction_factor y = float(df['GY'].values[i]) / contraction_factor id_ = df['ID'].values[i] bus = Bus(name=name, vnom=Vnom, xpos=x, ypos=y, height=40, width=60) circuit.add_bus(bus) buses_id_dict[id_] = bus else: logger.append(tpe + ' not recognised under Nodes') # create branches for tpe in data_structures['Branches']: # Condenser series or shunt # __headers__['Branches']['CAP'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'EQ', 'YEAR'] if tpe in ['CAP', 'IND']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] # get equipment reference in the catalogue eq_id = df['EQ'].values[i] df_cat = data_structures['CatalogBranch'][tpe] cat_elm = df_cat[df_cat['EQ'] == eq_id] try: x = float(cat_elm['REAC'].values[0]) * Sbase except: x = 1e-20 br = Branch(bus_from=b1, bus_to=b2, name=name, x=x, branch_type=BranchType.Branch) circuit.add_branch(br) # Estimator # __headers__['Branches']['ESTIM'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'INDEP', 'I', 'SIMULT'] if tpe in ['ESTIM']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] br = Branch(bus_from=b1, bus_to=b2, name=name, branch_type=BranchType.Branch) circuit.add_branch(br) # Breaker # __headers__['Branches']['DISJ'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT', # 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'YEAR', 'CONTROL'] # Fuse # __headers__['Branches']['FUS'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT', # 'TISOL','TRECONF', 'TREPAIR', 'EQ', 'YEAR'] # Switch # __headers__['Branches']['INTR'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT', # 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'YEAR', 'DRIVE', 'CONTROL'] # Disconnector # __headers__['Branches']['SECC'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT', # 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'YEAR', 'DRIVE', 'CONTROL'] if tpe in ['DISJ', 'FUS', 'INTR', 'SECC']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] state = bool(int(df['STAT'].values[i])) b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] br = Branch(bus_from=b1, bus_to=b2, name=name, active=state, branch_type=BranchType.Switch) circuit.add_branch(br) # Lines, cables and bars # fill until it fits or truncate the data # __headers__['Branches']['LINE'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'COLOR', 'GEOLEN', 'LEN', # 'STAT', # 'PERM', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'RERAT', 'EQEXIST', 'NPOSS', # 'CHOOSEQ', 'INSRTCOST', 'EQPOSS1', 'MATCOST1', 'EQPOSS2', 'MATCOST2', # 'EQPOSS3', # 'MATCOST3', 'NCOOG', 'GX1', 'GY1', 'GX2', 'GY2'] if tpe in ['LINE']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] length = float(df['LEN'].values[i]) # get equipment reference in the catalogue eq_id = df['EQEXIST'].values[i] df_cat = data_structures['CatalogBranch'][tpe] cat_elm = df_cat[df_cat['EQ'] == eq_id] try: r = float(cat_elm['R'].values[0]) * length / 1000 except: r = 1e-20 try: x = float(cat_elm['X'].values[0]) * length / 1000 except: x = 1e-20 try: b = float(cat_elm['B'].values[0]) * length / 1000 except: b = 1e-20 Imax = float( cat_elm['RATTYP'].values[0]) / 1000.0 # pass from A to kA Vnom = float(cat_elm['VNOM'].values[0]) # kV Smax = Imax * Vnom * SQRT3 # MVA # correct for zero values which are problematic r = r if r > 0.0 else 1e-20 x = x if x > 0.0 else 1e-20 b = b if b > 0.0 else 1e-20 br = Branch(bus_from=b1, bus_to=b2, name=name, r=r, x=x, b=b, rate=Smax, length=length, branch_type=BranchType.Line) circuit.add_branch(br) # Intensity Transformer # __headers__['Branches']['TI'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'INDEP', 'I', 'SIMULT', 'EXIST', 'STAT', # 'PERM', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'TAP1', 'TAP2', 'YEAR'] if tpe in ['TI']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] # get equipment reference in the catalogue eq_id = df['EQ'].values[i] df_cat = data_structures['CatalogBranch'][tpe] cat_elm = df_cat[df_cat['EQ'] == eq_id] br = Branch(bus_from=b1, bus_to=b2, name=name, branch_type=BranchType.Transformer) circuit.add_branch(br) # Self-transformer # __headers__['Branches']['XFORM1'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'ID3', 'ID1N', 'ID2N', 'ID3N', # 'EXIST', # 'STAT', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'RERAT', 'CON1', 'RE1', # 'XE1', # 'CON2', 'RE2', 'XE2', 'CON3', 'RE3', 'XE3', 'LOSS', 'TPERM', 'SETVSEL', # 'SETV', # 'EQ', 'TAP1', 'TAP2', 'TAP3', 'YEAR', 'NUM'] if tpe in ['XFORM1', 'XFORM2']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] # get equipment reference in the catalogue # eq_id = df['EQ'].values[i] eq_id = df['XE3'].values[ i] # to correct the bad data formatting these file has... df_cat = data_structures['CatalogBranch'][tpe] cat_elm = df_cat[df_cat['EQ'] == eq_id] if cat_elm.shape[0] > 0: r1 = float(cat_elm['RD1'].values[0]) r2 = float(cat_elm['RD2'].values[0]) x1 = float(cat_elm['XD1'].values[0]) x2 = float(cat_elm['XD2'].values[0]) s1 = float(cat_elm['SNOMTYP1'].values[0] ) / 1000.0 # from kVA to MVA s2 = float(cat_elm['SNOMTYP2'].values[0] ) / 1000.0 # from kVA to MVA r = r1 + r2 x = x1 + x2 s = s1 + s2 r = r if r > 0.0 else 1e-20 x = x if x > 0.0 else 1e-20 s = s if s > 0.0 else 1e-20 else: r = 1e-20 x = 1e-20 s = 1e-20 logger.append('The ' + tpe + ' type ' + eq_id + ' was not found.') br = Branch(bus_from=b1, bus_to=b2, name=name, r=r, x=x, rate=s, branch_type=BranchType.Transformer) circuit.add_branch(br) # 3-winding transformer # __headers__['Branches']['XFORM3'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'ID3', 'ID1N', 'ID2N', 'ID3N', # 'EXIST', # 'STAT', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'RERAT', 'CON1', 'RE1', # 'XE1', # 'CON2', 'RE2', 'XE2', 'CON3', 'RE3', 'XE3', 'LOSS', 'TPERM', 'SETVSEL', # 'SETV', # 'EQ', 'TAP1', 'TAP2', 'TAP3', 'YEAR', 'NUM'] if tpe in ['XFORM3']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] id3 = df['ID3'].values[i] b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] b3 = buses_id_dict[id3] # get equipment reference in the catalogue eq_id = df['EQ'].values[i] df_cat = data_structures['CatalogBranch'][tpe] cat_elm = df_cat[df_cat['EQ'] == eq_id] r1 = float(cat_elm['RD1'].values[0]) r2 = float(cat_elm['RD2'].values[0]) r3 = float(cat_elm['RD3'].values[0]) x1 = float(cat_elm['XD1'].values[0]) x2 = float(cat_elm['XD2'].values[0]) x3 = float(cat_elm['XD3'].values[0]) s1 = float( cat_elm['SNOMTYP1'].values[0]) / 1000.0 # from kVA to MVA s2 = float( cat_elm['SNOMTYP2'].values[0]) / 1000.0 # from kVA to MVA s3 = float( cat_elm['SNOMTYP3'].values[0]) / 1000.0 # from kVA to MVA r12 = r1 + r2 x12 = x1 + x2 s12 = s1 + s2 r13 = r1 + r3 x13 = x1 + x3 s13 = s1 + s3 r23 = r2 + r3 x23 = x2 + x3 s23 = s2 + s3 r12 = r12 if r12 > 0.0 else 1e-20 x12 = x12 if x12 > 0.0 else 1e-20 s12 = s12 if s12 > 0.0 else 1e-20 r13 = r13 if r13 > 0.0 else 1e-20 x13 = x13 if x13 > 0.0 else 1e-20 s13 = s13 if s13 > 0.0 else 1e-20 r23 = r23 if r23 > 0.0 else 1e-20 x23 = x23 if x23 > 0.0 else 1e-20 s23 = s23 if s23 > 0.0 else 1e-20 br = Branch(bus_from=b1, bus_to=b2, name=name, r=r12, x=x12, rate=s12, branch_type=BranchType.Transformer) circuit.add_branch(br) br = Branch(bus_from=b1, bus_to=b3, name=name, r=r13, x=x13, rate=s13, branch_type=BranchType.Transformer) circuit.add_branch(br) br = Branch(bus_from=b2, bus_to=b3, name=name, r=r23, x=x23, rate=s23, branch_type=BranchType.Transformer) circuit.add_branch(br) # Neutral impedance # __headers__['Branches']['ZN'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT', # 'TISOL','TRECONF', 'TREPAIR', 'EQ', 'YEAR'] if tpe in ['ZN']: df = data_structures['Branches'][tpe] for i in range(df.shape[0]): name = df['NAME'].values[i] id1 = df['ID1'].values[i] id2 = df['ID2'].values[i] b1 = buses_id_dict[id1] b2 = buses_id_dict[id2] br = Branch(bus_from=b1, bus_to=b2, name=name, branch_type=BranchType.Branch) circuit.add_branch(br) # return the circuit and the logs return circuit, logger
def get_branches_of_bus(B, j): """ Get the indices of the branches connected to the bus j :param B: Branch-bus CSC matrix :param j: bus index :return: list of branches in the bus """ return [B.indices[k] for k in range(B.indptr[j], B.indptr[j + 1])] if __name__ == '__main__': fname = 'D:\\GitHub\\GridCal\\Grids_and_profiles\\grids\\Reduction Model 2.xlsx' circuit = MultiCircuit() circuit.load_file(fname) circuit.compile() # form C threshold = 1e-5 m = len(circuit.branches) n = len(circuit.buses) C = lil_matrix((m, n), dtype=int) buses_dict = {bus: i for i, bus in enumerate(circuit.buses)} branches_to_keep_idx = list() branches_to_remove_idx = list() states = np.zeros(m, dtype=int) br_idx = [None] * m graph = Graph()
""" # Sbase shortcut Sbase = self.numerical_circuit.Sbase data = self.get_branch_flows() * Sbase df = pd.DataFrame(data=data, index=self.numerical_circuit.branch_names, columns=['Branch flow (MW)']) return df if __name__ == '__main__': main_circuit = MultiCircuit() # fname = 'D:\\GitHub\\GridCal\\Grids_and_profiles\\grids\\lynn5buspv.xlsx' fname = 'D:\\GitHub\\GridCal\\Grids_and_profiles\\grids\\IEEE 30 Bus with storage.xlsx' # fname = 'C:\\Users\\spenate\\Documents\\PROYECTOS\\Sensible\\Report\\Test3 - Batteries\\Evora test 3 with storage.xlsx' # fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE 30 Bus with storage.xlsx' print('Reading...') main_circuit.load_file(fname) problem = DcOpf(main_circuit, allow_load_shedding=True, allow_generation_shedding=True) # run default state problem.build_solvers() problem.set_default_state()
def load_iPA(file_name): circuit = MultiCircuit() with open(file_name) as json_file: data = json.load(json_file) # elements dictionaries xfrm_dict = {entry['IdEnRed']: entry for entry in data['Transformadores']} # nodes_dict = {entry['id']: entry for entry in data['Nudos']} nodes_dict = dict() buses_dict = dict() for entry in data['Nudos']: nodes_dict[entry['id']] = entry bus = Bus(name=str(entry['id'])) buses_dict[entry['id']] = bus if entry['id'] > 0: # omit the node 0 because it is the "earth node"... circuit.add_bus(bus) gen_dict = {entry['IdEnRed']: entry for entry in data['Generadores']} load_dict = {entry['IdEnRed']: entry for entry in data['Consumos']} sw_dict = {entry['IdEnRed']: entry for entry in data['Interruptores']} # main grid vector_red = data['Red'] ''' {'id': 0, 'Tipo': 1, 'E': 0, 'EFase': 0, 'Tomas': 0, 'R1': 1e-05, 'X1': 1e-05, 'R0': 1e-05, 'X0': 1e-05, 'RN': 1e-05, 'XN': 1e-05, 'P': 0, 'Q': 0, 'Nudo1': 2410, 'Nudo2': 2403, 'Carga_Max': -1, 'ClassID': 1090, 'ClassMEMBER': 98076366, 'Conf': 'abc', 'LineaMT': '2030:98075347', 'Unom': 15.0} ''' for entry in vector_red: # pick the general attributes identifier = entry['id'] tpe = entry['Tipo'] n1_id = entry['Nudo1'] n2_id = entry['Nudo2'] # get the Bus objects associated to the bus indices if n1_id in buses_dict.keys(): bus1 = buses_dict[n1_id] if n2_id in buses_dict.keys(): bus2 = buses_dict[n2_id] if tpe == 0: # Fuente de Tensión(elemento Ptheta) # pick the bus that is not the earth bus... if n1_id == 0: bus = bus2 else: bus = bus1 bus.is_slack = True elm = ControlledGenerator(name='Slack') circuit.add_controlled_generator(bus, elm) elif tpe == 1: # Elemento impedancia(lineas) V = entry['Unom'] Zbase = V * V / circuit.Sbase if identifier in load_dict.keys(): # load!!! print('Load found in lines: WTF?') else: # line!!! r = entry['R1'] / Zbase x = entry['X1'] / Zbase if r > 1e-5: branch_type = BranchType.Line else: # mark as "generic branch" the branches with very low resistance branch_type = BranchType.Branch elm = Branch(bus_from=bus1, bus_to=bus2, name=str(identifier), r=r, x=x, branch_type=branch_type) circuit.add_branch(elm) elif tpe == 2: # Elemento PQ # pick the bus that is not the earth bus... if n1_id == 0: bus = bus2 else: bus = bus1 p = entry['P'] # power in MW q = entry['Q'] elm = Load(name=str(identifier), power=complex(p, q) * 1e-3) circuit.add_load(bus, elm) elif tpe == 3: # Elemento PV pass elif tpe == 4: # Reg de tensión V = entry['Unom'] Zbase = V * V / circuit.Sbase r = entry['R1'] / Zbase x = entry['X1'] / Zbase elm = Branch(bus_from=bus1, bus_to=bus2, name=str(identifier), r=r, x=x, branch_type=BranchType.Transformer) circuit.add_branch(elm) elif tpe == 5: # Transformador V = entry['Unom'] Zbase = V * V / circuit.Sbase r = entry['R1'] / Zbase x = entry['X1'] / Zbase elm = Branch(bus_from=bus1, bus_to=bus2, name=str(identifier), r=r, x=x, branch_type=BranchType.Transformer) circuit.add_branch(elm) # return the circuit return circuit
def __init__(self, multi_circuit: MultiCircuit, options: PowerFlowOptions, verbose=False, break_at_value=True, good_enough_value=0): self.break_at_value = break_at_value self.good_enough_value = good_enough_value self.multi_circuit = multi_circuit self.numerical_circuit = self.multi_circuit.compile() self.calculation_inputs = self.numerical_circuit.compute(add_storage=False, add_generation=True) self.pf = PowerFlowMP(self.multi_circuit, options) # indices of generators that contribute to the static power vector 'S' self.gen_s_idx = np.where((np.logical_not(self.numerical_circuit.controlled_gen_dispatchable) * self.numerical_circuit.controlled_gen_enabled) == True)[0] self.bat_s_idx = np.where((np.logical_not(self.numerical_circuit.battery_dispatchable) * self.numerical_circuit.battery_enabled) == True)[0] # indices of generators that are to be optimized via the solution vector 'x' self.gen_x_idx = np.where((self.numerical_circuit.controlled_gen_dispatchable * self.numerical_circuit.controlled_gen_enabled) == True)[0] self.bat_x_idx = np.where((self.numerical_circuit.battery_dispatchable * self.numerical_circuit.battery_enabled) == True)[0] self.n_batteries = len(self.numerical_circuit.battery_power) self.n_controlled_gen = len(self.numerical_circuit.controlled_gen_power) # compute the problem dimension self.dim = len(self.gen_x_idx) + len(self.bat_x_idx) # get the limits of the devices to control gens = np.array(multi_circuit.get_controlled_generators()) bats = np.array(multi_circuit.get_batteries()) gen_x_up = np.array([elm.Pmax for elm in gens[self.gen_x_idx]]) gen_x_low = np.array([elm.Pmin for elm in gens[self.gen_x_idx]]) bat_x_up = np.array([elm.Pmax for elm in bats[self.bat_x_idx]]) bat_x_low = np.array([elm.Pmin for elm in bats[self.bat_x_idx]]) self.ngen = len(self.gen_x_idx) self.xlow = np.r_[gen_x_low, bat_x_low] / self.multi_circuit.Sbase self.xup = np.r_[gen_x_up, bat_x_up] / self.multi_circuit.Sbase self.range = self.xup - self.xlow # form S static ################################################################################################ # all the loads apply self.Sfix = None self.set_default_state() # build Sfix self.Vbus = np.ones(self.numerical_circuit.nbus, dtype=complex) self.Ibus = np.zeros(self.numerical_circuit.nbus, dtype=complex) # other vars needed ############################################################################################ self.converged = False self.result = None self.force_batteries_to_charge = False self.x = np.zeros(self.dim) self.fx = 0 self.t = 0 self.Emin = None self.Emax = None self.E = None self.bat_idx = None self.battery_loading_pu = 0.01 self.dt = 0
def test_xfo_static_tap_3(): """ Basic test with the main transformer's HV tap (X_C3) set at -2.5% (0.975 pu), which raises the LV by the same amount (+2.5%). """ grid = MultiCircuit(name=test_name) grid.Sbase = Sbase grid.time_profile = None grid.logger = list() # Create buses POI = Bus( name="POI", vnom=100, # kV is_slack=True) grid.add_bus(POI) B_C3 = Bus(name="B_C3", vnom=10) # kV grid.add_bus(B_C3) B_MV_M32 = Bus(name="B_MV_M32", vnom=10) # kV grid.add_bus(B_MV_M32) B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) # kV grid.add_bus(B_LV_M32) # Create voltage controlled generators (or slack, a.k.a. swing) UT = ControlledGenerator(name="Utility") UT.bus = POI grid.add_controlled_generator(POI, UT) # Create static generators (with fixed power factor) M32 = StaticGenerator(name="M32", power=4.2 + 0.0j) # MVA (complex) M32.bus = B_LV_M32 grid.add_static_generator(B_LV_M32, M32) # Create transformer types s = 5 # MVA z = 8 # % xr = 40 SS = TransformerType( name="SS", hv_nominal_voltage=100, # kV lv_nominal_voltage=10, # kV nominal_power=s, copper_losses=complexe(z, xr).real * s * 1000 / Sbase, iron_losses=6.25, # kW no_load_current=0.5, # % short_circuit_voltage=z) grid.add_transformer_type(SS) s = 5 # MVA z = 6 # % xr = 20 PM = TransformerType( name="PM", hv_nominal_voltage=10, # kV lv_nominal_voltage=0.6, # kV nominal_power=s, copper_losses=complexe(z, xr).real * s * 1000 / Sbase, iron_losses=6.25, # kW no_load_current=0.5, # % short_circuit_voltage=z) grid.add_transformer_type(PM) # Create branches X_C3 = Branch(bus_from=POI, bus_to=B_C3, name="X_C3", branch_type=BranchType.Transformer, template=SS, tap=0.975) # update to a more precise tap changer X_C3.apply_tap_changer( TapChanger(taps_up=20, taps_down=20, max_reg=1.1, min_reg=0.9)) grid.add_branch(X_C3) C_M32 = Branch(bus_from=B_C3, bus_to=B_MV_M32, name="C_M32", r=0.784, x=0.174) grid.add_branch(C_M32) X_M32 = Branch(bus_from=B_MV_M32, bus_to=B_LV_M32, name="X_M32", branch_type=BranchType.Transformer, template=PM) grid.add_branch(X_M32) # Apply templates (device types) grid.apply_all_branch_types() print("Buses:") for i, b in enumerate(grid.buses): print(f" - bus[{i}]: {b}") print() grid.compile() options = PowerFlowOptions(SolverType.NR, verbose=True, robust=True, initialize_with_existing_solution=True, multi_core=True, control_q=True, control_taps=True, tolerance=1e-6, max_iter=15) power_flow = PowerFlow(grid, options) power_flow.run() print() print(f"Test: {test_name}") print() print("Controlled generators:") for g in grid.get_controlled_generators(): print(f" - Generator {g}: q_min={g.Qmin} MVAR, q_max={g.Qmax} MVAR") print() print("Branches:") for b in grid.branches: print(f" - {b}:") print(f" R = {round(b.R, 4)} pu") print(f" X = {round(b.X, 4)} pu") print(f" X/R = {round(b.X/b.R, 1)}") print(f" G = {round(b.G, 4)} pu") print(f" B = {round(b.B, 4)} pu") print() print("Transformer types:") for t in grid.transformer_types: print( f" - {t}: Copper losses={int(t.Copper_losses)}kW, " f"Iron losses={int(t.Iron_losses)}kW, SC voltage={t.Short_circuit_voltage}%" ) print() print("Losses:") for i in range(len(grid.branches)): print( f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA" ) print() equal = False for i, branch in enumerate(grid.branches): if branch.name == "X_C3": equal = power_flow.results.tap_module[i] == branch.tap_module if not equal: grid.export_pf(f"{test_name}_results.xlsx", power_flow.results) grid.save_excel(f"{test_name}_grid.xlsx") assert equal
d = {1: 'PQ', 2: 'PV', 3: 'VD'} tpe_str = array([d[i] for i in tpe], dtype=object) data = c_[tpe_str, Sbus.real, Sbus.imag, vm, va] cols = ['Type', 'P', 'Q', '|V|', 'angle'] df = pd.DataFrame(data=data, columns=cols) return df if __name__ == '__main__': from GridCal.Engine.CalculationEngine import MultiCircuit, PowerFlowOptions, PowerFlow, SolverType from matplotlib import pyplot as plt grid = MultiCircuit() # grid.load_file('lynn5buspq.xlsx') # grid.load_file('lynn5buspv.xlsx') # grid.load_file('IEEE30.xlsx') # grid.load_file('/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE 14.xlsx') # grid.load_file('/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE39.xlsx') # grid.load_file('/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/1354 Pegase.xlsx') grid.load_file( '/home/santi/Documentos/GitHub/GridCal/UnderDevelopment/GridCal/Monash2.xlsx' ) grid.compile() circuit = grid.circuits[0] print('\nYbus:\n', circuit.power_flow_input.Ybus.todense())
def test_xfo_static_tap_1(): """ Basic test with the main transformer's HV tap (X_C3) set at +5% (1.05 pu), which lowers the LV by the same amount (-5%). """ grid = MultiCircuit(name=test_name) grid.Sbase = Sbase grid.time_profile = None grid.logger = list() # Create buses POI = Bus( name="POI", vnom=100, #kV is_slack=True) grid.add_bus(POI) B_C3 = Bus(name="B_C3", vnom=10) #kV grid.add_bus(B_C3) B_MV_M32 = Bus(name="B_MV_M32", vnom=10) #kV grid.add_bus(B_MV_M32) B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) #kV grid.add_bus(B_LV_M32) # Create voltage controlled generators (or slack, a.k.a. swing) UT = ControlledGenerator(name="Utility") UT.bus = POI grid.add_controlled_generator(POI, UT) # Create static generators (with fixed power factor) M32 = StaticGenerator(name="M32", power=4.2 + 0.0j) # MVA (complex) M32.bus = B_LV_M32 grid.add_static_generator(B_LV_M32, M32) # Create transformer types s = 5 # MVA z = 8 # % xr = 40 SS = TransformerType( name="SS", hv_nominal_voltage=100, # kV lv_nominal_voltage=10, # kV nominal_power=s, copper_losses=complexe(z, xr).real * s * 1000 / Sbase, iron_losses=6.25, # kW no_load_current=0.5, # % short_circuit_voltage=z) grid.add_transformer_type(SS) s = 5 # MVA z = 6 # % xr = 20 PM = TransformerType( name="PM", hv_nominal_voltage=10, # kV lv_nominal_voltage=0.6, # kV nominal_power=s, copper_losses=complexe(z, xr).real * s * 1000 / Sbase, iron_losses=6.25, # kW no_load_current=0.5, # % short_circuit_voltage=z) grid.add_transformer_type(PM) # Create branches X_C3 = Branch(bus_from=POI, bus_to=B_C3, name="X_C3", branch_type=BranchType.Transformer, template=SS, tap=1.05) grid.add_branch(X_C3) C_M32 = Branch(bus_from=B_C3, bus_to=B_MV_M32, name="C_M32", r=0.784, x=0.174) grid.add_branch(C_M32) X_M32 = Branch(bus_from=B_MV_M32, bus_to=B_LV_M32, name="X_M32", branch_type=BranchType.Transformer, template=PM) grid.add_branch(X_M32) # Apply templates (device types) grid.apply_all_branch_types() print("Buses:") for i, b in enumerate(grid.buses): print(f" - bus[{i}]: {b}") print() grid.compile() options = PowerFlowOptions(SolverType.LM, verbose=True, robust=True, initialize_with_existing_solution=True, multi_core=True, control_q=True, tolerance=1e-6, max_iter=99) power_flow = PowerFlow(grid, options) power_flow.run() approx_volt = [round(100 * abs(v), 1) for v in power_flow.results.voltage] solution = [100.0, 94.7, 98.0, 98.1] # Expected solution from GridCal print() print(f"Test: {test_name}") print(f"Results: {approx_volt}") print(f"Solution: {solution}") print() print("Controlled generators:") for g in grid.get_controlled_generators(): print(f" - Generator {g}: q_min={g.Qmin} MVAR, q_max={g.Qmax} MVAR") print() print("Branches:") for b in grid.branches: print(f" - {b}:") print(f" R = {round(b.R, 4)} pu") print(f" X = {round(b.X, 4)} pu") print(f" X/R = {round(b.X/b.R, 1)}") print(f" G = {round(b.G, 4)} pu") print(f" B = {round(b.B, 4)} pu") print() print("Transformer types:") for t in grid.transformer_types: print( f" - {t}: Copper losses={int(t.Copper_losses)}kW, Iron losses={int(t.Iron_losses)}kW, SC voltage={t.Short_circuit_voltage}%" ) print() print("Losses:") for i in range(len(grid.branches)): print( f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA" ) print() equal = True for i in range(len(approx_volt)): if approx_volt[i] != solution[i]: equal = False assert equal
class Blockchain: def __init__(self, agent_id_to_grid_id, fname='Grid.xlsx', dt=1): self.current_transactions = Transactions() self.chain = [] self.nodes = set() self.agent_id_to_grid_id = agent_id_to_grid_id self.actors_group = ActorsGroup() self.market = Market(actors_group=self.actors_group) self.dt = dt self.grid = MultiCircuit() self.grid.load_file(fname) # Create the genesis block self.new_block(previous_hash='1', proof=100) def register_node(self, address): """ Add a new node to the list of nodes :param address: Address of node. Eg. 'http://192.168.0.5:5000' """ parsed_url = urlparse(address) if parsed_url.netloc: self.nodes.add(parsed_url.netloc) elif parsed_url.path: # Accepts an URL without scheme like '192.168.0.5:5000'. self.nodes.add(parsed_url.path) else: raise ValueError('Invalid URL') def valid_chain(self, chain): """ Determine if a given blockchain is valid :param chain: A blockchain :return: True if valid, False if not """ last_block = chain[0] current_index = 1 while current_index < len(chain): block = chain[current_index] print(f'{last_block}') print(f'{block}') print("\n-----------\n") # Check that the hash of the block is correct last_block_hash = self.hash(last_block) if block['previous_hash'] != last_block_hash: return False # Check that the Proof of Work is correct if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash): return False last_block = block current_index += 1 return True def resolve_conflicts(self): """ This is our consensus algorithm, it resolves conflicts by replacing our chain with the longest one in the network. :return: True if our chain was replaced, False if not """ neighbours = self.nodes new_chain = None # We're only looking for chains longer than ours max_length = len(self.chain) # Grab and verify the chains from all the nodes in our network for node in neighbours: response = requests.get(f'http://{node}/chain') if response.status_code == 200: length = response.json()['length'] chain = response.json()['chain'] # Check if the length is longer and the chain is valid if length > max_length and self.valid_chain(chain): max_length = length new_chain = chain # Replace our chain if we discovered a new, valid chain longer than ours if new_chain: self.chain = new_chain return True return False def new_block(self, proof, previous_hash): """ Create a new Block in the Blockchain :param proof: The proof given by the Proof of Work algorithm :param previous_hash: Hash of previous Block :return: New Block """ block = { 'index': len(self.chain) + 1, 'timestamp': time(), 'transactions': self.current_transactions, 'proof': proof, 'previous_hash': previous_hash or self.hash(self.chain[-1]), } # Reset the current list of transactions self.current_transactions = [] self.chain.append(block) return block def new_transaction(self, sender, recipient, energy_amount, price, bid_type, electric_hash): """ Creates a new transaction to go into the next mined Block :param sender: Address of the Sender :param recipient: Address of the Recipient :param amount: Amount :return: The index of the Block that will hold this transaction """ tr = Transaction(bid_id=len(self.current_transactions), # this may be repeated but it is only used to print seller_id=sender, buyer_id=recipient, energy_amount=energy_amount, price=price, bid_type=bid_type, bid_hash=electric_hash) # self.current_transactions.append({ # 'sender': sender, # 'recipient': recipient, # 'energy_amount': energy_amount, # 'price': price, # 'bid_type': bid_type, # 'electric_hash': electric_hash # }) self.current_transactions.append(tr) return self.last_block['index'] + 1 @property def last_block(self): return self.chain[-1] @staticmethod def hash(block): """ Creates a SHA-256 hash of a Block :param block: Block """ # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes # block_string = json.dumps(block, sort_keys=True).encode() block_string = str(block['index']) + \ str(block['timestamp']) + \ str(block['proof']) + \ str(block['previous_hash']) + \ str([j.hash for j in block['transactions']]) # block_string = block. # block_string = block.to_json() return hashlib.sha256(block_string.encode('UTF-8')).hexdigest() @staticmethod def valid_proof( proof ): """ Validates the Proof :param proof: <int> Current Proof :return: <bool> True if correct, False if not. """ return proof != None
def test_basic(): """ Basic GridCal test, also useful for a basic tutorial. In this case the magnetizing branch of the transformers is neglected by inputting 1e-20 excitation current and iron core losses. The results are identical to ETAP's, which always uses this assumption in balanced load flow calculations. """ grid = MultiCircuit(name=test_name) grid.Sbase = Sbase grid.time_profile = None grid.logger = list() # Create buses POI = Bus( name="POI", vnom=100, #kV is_slack=True) grid.add_bus(POI) B_C3 = Bus(name="B_C3", vnom=10) #kV grid.add_bus(B_C3) B_MV_M32 = Bus(name="B_MV_M32", vnom=10) #kV grid.add_bus(B_MV_M32) B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) #kV grid.add_bus(B_LV_M32) # Create voltage controlled generators (or slack, a.k.a. swing) UT = ControlledGenerator(name="Utility") UT.bus = POI grid.add_controlled_generator(POI, UT) # Create static generators (with fixed power factor) M32 = StaticGenerator(name="M32", power=4.2 + 0.0j) # MVA (complex) M32.bus = B_LV_M32 grid.add_static_generator(B_LV_M32, M32) # Create transformer types s = 5 # MVA z = 8 # % xr = 40 SS = TransformerType( name="SS", hv_nominal_voltage=100, # kV lv_nominal_voltage=10, # kV nominal_power=s, copper_losses=complexe(z, xr).real * s * 1000 / Sbase, iron_losses=1e-20, no_load_current=1e-20, short_circuit_voltage=z) grid.add_transformer_type(SS) s = 5 # MVA z = 6 # % xr = 20 PM = TransformerType( name="PM", hv_nominal_voltage=10, # kV lv_nominal_voltage=0.6, # kV nominal_power=s, copper_losses=complexe(z, xr).real * s * 1000 / Sbase, iron_losses=1e-20, no_load_current=1e-20, short_circuit_voltage=z) grid.add_transformer_type(PM) # Create branches X_C3 = Branch(bus_from=POI, bus_to=B_C3, name="X_C3", branch_type=BranchType.Transformer, template=SS) grid.add_branch(X_C3) C_M32 = Branch(bus_from=B_C3, bus_to=B_MV_M32, name="C_M32", r=0.784, x=0.174) grid.add_branch(C_M32) X_M32 = Branch(bus_from=B_MV_M32, bus_to=B_LV_M32, name="X_M32", branch_type=BranchType.Transformer, template=PM) grid.add_branch(X_M32) # Apply templates (device types) grid.apply_all_branch_types() print("Buses:") for i, b in enumerate(grid.buses): print(f" - bus[{i}]: {b}") print() grid.compile() options = PowerFlowOptions(SolverType.LM, verbose=True, robust=True, initialize_with_existing_solution=True, multi_core=True, control_q=True, tolerance=1e-6, max_iter=99) power_flow = PowerFlow(grid, options) power_flow.run() approx_volt = [round(100 * abs(v), 1) for v in power_flow.results.voltage] solution = [ 100.0, 99.6, 102.7, 102.9 ] # Expected solution from GridCal and ETAP 16.1.0, for reference print() print(f"Test: {test_name}") print(f"Results: {approx_volt}") print(f"Solution: {solution}") print() print("Controlled generators:") for g in grid.get_controlled_generators(): print(f" - Generator {g}: q_min={g.Qmin}pu, q_max={g.Qmax}pu") print() print("Branches:") for b in grid.branches: print(f" - {b}:") print(f" R = {round(b.R, 4)} pu") print(f" X = {round(b.X, 4)} pu") print(f" X/R = {round(b.X/b.R, 1)}") print(f" G = {round(b.G, 4)} pu") print(f" B = {round(b.B, 4)} pu") print() print("Transformer types:") for t in grid.transformer_types: print( f" - {t}: Copper losses={int(t.Copper_losses)}kW, Iron losses={int(t.Iron_losses)}kW, SC voltage={t.Short_circuit_voltage}%" ) print() print("Losses:") for i in range(len(grid.branches)): print( f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA" ) print() equal = True for i in range(len(approx_volt)): if approx_volt[i] != solution[i]: equal = False assert equal
def test_pv_1(): """ Voltage controlled generator test, also useful for a basic tutorial. In this case the generator M32 regulates the voltage at a setpoint of 1.025 pu, and the slack bus (POI) regulates it at 1.0 pu. The transformers' magnetizing branch losses are considered, but their voltage regulators aren't. """ grid = MultiCircuit(name=test_name) grid.Sbase = Sbase grid.time_profile = None grid.logger = list() # Create buses POI = Bus(name="POI", vnom=100, #kV is_slack=True) grid.add_bus(POI) B_MV_M32 = Bus(name="B_MV_M32", vnom=10) #kV grid.add_bus(B_MV_M32) B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) #kV grid.add_bus(B_LV_M32) # Create voltage controlled generators (or slack, a.k.a. swing) UT = ControlledGenerator(name="Utility") UT.bus = POI grid.add_controlled_generator(POI, UT) M32 = ControlledGenerator(name="M32", active_power=4.2, voltage_module=1.025, Qmin=-2.5, Qmax=2.5) M32.bus = B_LV_M32 grid.add_controlled_generator(B_LV_M32, M32) # Create transformer types s = 100 # MVA z = 8 # % xr = 40 SS = TransformerType(name="SS", hv_nominal_voltage=100, # kV lv_nominal_voltage=10, # kV nominal_power=s, copper_losses=complexe(z, xr).real*s*1000/Sbase, iron_losses=125, # kW no_load_current=0.5, # % short_circuit_voltage=z) grid.add_transformer_type(SS) s = 5 # MVA z = 6 # % xr = 20 PM = TransformerType(name="PM", hv_nominal_voltage=10, # kV lv_nominal_voltage=0.6, # kV nominal_power=s, copper_losses=complexe(z, xr).real*s*1000/Sbase, iron_losses=6.25, # kW no_load_current=0.5, # % short_circuit_voltage=z) grid.add_transformer_type(PM) # Create branches X_C3 = Branch(bus_from=POI, bus_to=B_MV_M32, name="X_C3", branch_type=BranchType.Transformer, template=SS) grid.add_branch(X_C3) X_M32 = Branch(bus_from=B_MV_M32, bus_to=B_LV_M32, name="X_M32", branch_type=BranchType.Transformer, template=PM) grid.add_branch(X_M32) # Apply templates (device types) grid.apply_all_branch_types() print("Buses:") for i, b in enumerate(grid.buses): print(f" - bus[{i}]: {b}") print() grid.compile() options = PowerFlowOptions(SolverType.LM, verbose=True, robust=True, initialize_with_existing_solution=True, multi_core=True, control_q=True, tolerance=1e-6, max_iter=99) power_flow = PowerFlow(grid, options) power_flow.run() approx_volt = [round(100*abs(v), 1) for v in power_flow.results.voltage] solution = [100.0, 100.1, 102.5] # Expected solution from GridCal and ETAP 16.1.0, for reference print() print(f"Test: {test_name}") print(f"Results: {approx_volt}") print(f"Solution: {solution}") print() print("Controlled generators:") for g in grid.get_controlled_generators(): print(f" - Generator {g}: q_min={g.Qmin}pu, q_max={g.Qmax}pu") print() print("Branches:") for b in grid.branches: print(f" - {b}:") print(f" R = {round(b.R, 4)} pu") print(f" X = {round(b.X, 4)} pu") print(f" X/R = {round(b.X/b.R, 1)}") print(f" G = {round(b.G, 4)} pu") print(f" B = {round(b.B, 4)} pu") print() print("Transformer types:") for t in grid.transformer_types: print(f" - {t}: Copper losses={int(t.Copper_losses)}kW, Iron losses={int(t.Iron_losses)}kW, SC voltage={t.Short_circuit_voltage}%") print() print("Losses:") for i in range(len(grid.branches)): print(f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA") print() equal = True for i in range(len(approx_volt)): if approx_volt[i] != solution[i]: equal = False assert equal
self.progress_signal.emit(0.0) self.done_signal.emit() def cancel(self): """ Cancel the simulation :return: """ self.__cancel__ = True self.progress_signal.emit(0.0) self.progress_text.emit('Cancelled') self.done_signal.emit() if __name__ == '__main__': from matplotlib import pyplot as plt # fname = 'D:\\GitHub\\GridCal\\Grids_and_profiles\\grids\\Reduction Model 3.xlsx' fname = 'D:\\GitHub\\GridCal\\UnderDevelopment\\GridCal\\Engine\\Importers\\Export_sensible_v15_modif.json.xlsx' circuit_ = MultiCircuit() circuit_.load_file(fname) # circuit.compile() top = TopologyReduction(grid=circuit_, rx_criteria=False, rx_threshold=1e-5, type_criteria=True, selected_type=BranchType.Branch) top.run() # circuit_.compile() # circuit_.plot_graph() # plt.show()
def test_gridcal_regulator(): """ GridCal test for the new implementation of transformer voltage regulators. """ grid = MultiCircuit(name=test_name) grid.Sbase = Sbase grid.time_profile = None grid.logger = list() # Create buses POI = Bus( name="POI", vnom=100, #kV is_slack=True) grid.add_bus(POI) B_C3 = Bus(name="B_C3", vnom=10) #kV grid.add_bus(B_C3) B_MV_M32 = Bus(name="B_MV_M32", vnom=10) #kV grid.add_bus(B_MV_M32) B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) #kV grid.add_bus(B_LV_M32) # Create voltage controlled generators (or slack, a.k.a. swing) UT = ControlledGenerator(name="Utility") UT.bus = POI grid.add_controlled_generator(POI, UT) # Create static generators (with fixed power factor) M32 = StaticGenerator(name="M32", power=4.2 + 0.0j) # MVA (complex) M32.bus = B_LV_M32 grid.add_static_generator(B_LV_M32, M32) # Create transformer types s = 100 # MVA z = 8 # % xr = 40 SS = TransformerType( name="SS", hv_nominal_voltage=100, # kV lv_nominal_voltage=10, # kV nominal_power=s, # MVA copper_losses=get_complex(z, xr).real * s * 1000 / Sbase, # kW iron_losses=125, # kW no_load_current=0.5, # % short_circuit_voltage=z) # % grid.add_transformer_type(SS) s = 5 # MVA z = 6 # % xr = 20 PM = TransformerType( name="PM", hv_nominal_voltage=10, # kV lv_nominal_voltage=0.6, # kV nominal_power=s, # MVA copper_losses=get_complex(z, xr).real * s * 1000 / Sbase, # kW iron_losses=6.25, # kW no_load_current=0.5, # % short_circuit_voltage=z) # % grid.add_transformer_type(PM) # Create branches X_C3 = Branch(bus_from=POI, bus_to=B_C3, name="X_C3", branch_type=BranchType.Transformer, template=SS, bus_to_regulated=True, vset=1.05) X_C3.tap_changer = TapChanger(taps_up=16, taps_down=16, max_reg=1.1, min_reg=0.9) X_C3.tap_changer.set_tap(X_C3.tap_module) grid.add_branch(X_C3) C_M32 = Branch(bus_from=B_C3, bus_to=B_MV_M32, name="C_M32", r=7.84, x=1.74) grid.add_branch(C_M32) X_M32 = Branch(bus_from=B_MV_M32, bus_to=B_LV_M32, name="X_M32", branch_type=BranchType.Transformer, template=PM) grid.add_branch(X_M32) # Apply templates (device types) grid.apply_all_branch_types() print("Buses:") for i, b in enumerate(grid.buses): print(f" - bus[{i}]: {b}") print() grid.compile() options = PowerFlowOptions(SolverType.LM, verbose=True, robust=True, initialize_with_existing_solution=True, multi_core=True, control_q=True, control_taps=True, tolerance=1e-6, max_iter=99) power_flow = PowerFlowMP(grid, options) power_flow.run() approx_volt = [round(100 * abs(v), 1) for v in power_flow.results.voltage] solution = [100.0, 105.2, 130.0, 130.1] # Expected solution from GridCal print() print(f"Test: {test_name}") print(f"Results: {approx_volt}") print(f"Solution: {solution}") print() print("Controlled generators:") for g in grid.get_controlled_generators(): print(f" - Generator {g}: q_min={g.Qmin}pu, q_max={g.Qmax}pu") print() print("Branches:") for b in grid.branches: print( f" - {b}: R={round(b.R, 4)}pu, X={round(b.X, 4)}pu, X/R={round(b.X/b.R, 1)}, vset={b.vset}" ) print() print("Transformer types:") for t in grid.transformer_types: print( f" - {t}: Copper losses={int(t.Copper_losses)}kW, Iron losses={int(t.Iron_losses)}kW, SC voltage={t.Short_circuit_voltage}%" ) print() print("Losses:") for i in range(len(grid.branches)): print( f" - {grid.branches[i]}: losses={round(power_flow.results.losses[i], 3)} MVA" ) print() print(f"Voltage settings: {grid.numerical_circuit.vset}") #print("GridCal logger:") #for l in grid.logger: #print(f" - {l}") equal = True for i in range(len(approx_volt)): if approx_volt[i] != solution[i]: equal = False assert equal
def __init__(self, multi_circuit: MultiCircuit, verbose=False): ################################################################################################################ # Compilation ################################################################################################################ self.verbose = verbose self.multi_circuit = multi_circuit self.numerical_circuit = self.multi_circuit.compile() self.islands = self.numerical_circuit.compute() # indices of generators that contribute to the static power vector 'S' self.gen_s_idx = np.where((np.logical_not(self.numerical_circuit.controlled_gen_dispatchable) * self.numerical_circuit.controlled_gen_enabled) == True)[0] self.bat_s_idx = np.where((np.logical_not(self.numerical_circuit.battery_dispatchable) * self.numerical_circuit.battery_enabled) == True)[0] # indices of generators that are to be optimized via the solution vector 'x' self.gen_x_idx = np.where((self.numerical_circuit.controlled_gen_dispatchable * self.numerical_circuit.controlled_gen_enabled) == True)[0] self.bat_x_idx = np.where((self.numerical_circuit.battery_dispatchable * self.numerical_circuit.battery_enabled) == True)[0] # compute the problem dimension dim = len(self.gen_x_idx) + len(self.bat_x_idx) # get the limits of the devices to control gens = np.array(multi_circuit.get_controlled_generators()) bats = np.array(multi_circuit.get_batteries()) gen_x_up = np.array([elm.Pmax for elm in gens[self.gen_x_idx]]) gen_x_low = np.array([elm.Pmin for elm in gens[self.gen_x_idx]]) bat_x_up = np.array([elm.Pmax for elm in bats[self.bat_x_idx]]) bat_x_low = np.array([elm.Pmin for elm in bats[self.bat_x_idx]]) # form S static ################################################################################################ # all the loads apply self.Sfix = self.numerical_circuit.C_load_bus.T * ( - self.numerical_circuit.load_power / self.numerical_circuit.Sbase * self.numerical_circuit.load_enabled) # static generators (all apply) self.Sfix += self.numerical_circuit.C_sta_gen_bus.T * ( self.numerical_circuit.static_gen_power / self.numerical_circuit.Sbase * self.numerical_circuit.static_gen_enabled) # controlled generators self.Sfix += (self.numerical_circuit.C_ctrl_gen_bus[self.gen_s_idx, :]).T * ( self.numerical_circuit.controlled_gen_power[self.gen_s_idx] / self.numerical_circuit.Sbase) # batteries self.Sfix += (self.numerical_circuit.C_batt_bus[self.bat_s_idx, :]).T * ( self.numerical_circuit.battery_power[self.bat_s_idx] / self.numerical_circuit.Sbase) # build A_sys per island ####################################################################################### for island in self.islands: island.build_linear_ac_sys_mat() # builds the A matrix factorization and stores it internally ################################################################################################################ # internal variables for PySOT ################################################################################################################ self.xlow = np.r_[gen_x_low, bat_x_low] / self.multi_circuit.Sbase self.xup = np.r_[gen_x_up, bat_x_up] / self.multi_circuit.Sbase self.dim = dim self.info = str(dim) + "-dimensional OPF problem" self.min = 0 self.integer = [] self.continuous = np.arange(0, dim) check_opt_prob(self)
d = {1: 'PQ', 2: 'PV', 3: 'VD'} tpe_str = array([d[i] for i in tpe], dtype=object) data = c_[tpe_str, Sbus.real, Sbus.imag, vm, va] cols = ['Type', 'P', 'Q', '|V|', 'angle'] df = pd.DataFrame(data=data, columns=cols) return df if __name__ == '__main__': from GridCal.Engine.CalculationEngine import MultiCircuit, PowerFlowOptions, PowerFlow, SolverType from matplotlib import pyplot as plt grid = MultiCircuit() # grid.load_file('lynn5buspq.xlsx') # grid.load_file('lynn5buspv.xlsx') # grid.load_file('IEEE30.xlsx') grid.load_file( '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE 14.xlsx' ) # grid.load_file('/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE39.xlsx') # grid.load_file('/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/1354 Pegase.xlsx') grid.compile() circuit = grid.circuits[0] print('\nYbus:\n', circuit.power_flow_input.Ybus.todense()) print('\nSbus:\n', circuit.power_flow_input.Sbus)
return V, converged, normF, Scalc ######################################################################################################################## # MAIN ######################################################################################################################## if __name__ == "__main__": from GridCal.Engine.CalculationEngine import MultiCircuit, PowerFlowOptions, PowerFlow, SolverType import pandas as pd pd.set_option('display.max_rows', 500) pd.set_option('display.max_columns', 500) pd.set_option('display.width', 1000) grid = MultiCircuit() # grid.load_file('lynn5buspq.xlsx') grid.load_file('IEEE30.xlsx') # grid.load_file('/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE 145 Bus.xlsx') grid.compile() circuit = grid.circuits[0] print('\nYbus:\n', circuit.power_flow_input.Ybus.todense()) print('\nYseries:\n', circuit.power_flow_input.Yseries.todense()) print('\nYshunt:\n', circuit.power_flow_input.Yshunt) print('\nSbus:\n', circuit.power_flow_input.Sbus) print('\nIbus:\n', circuit.power_flow_input.Ibus) print('\nVbus:\n', circuit.power_flow_input.Vbus) print('\ntypes:\n', circuit.power_flow_input.types) print('\npq:\n', circuit.power_flow_input.pq)