Untitled

def medidas(self, baseva: int) -> pd.DataFrame:
        barras = self.indexar_barras()
        erro_aleatorio_medidor_pot = np.random.choice(np.arange(0.01, 0.021, 0.001))
        erro_aleatorio_medidor_tensao = np.random.choice(np.arange(0.002, 0.011, 0.001))

        dp_padrao_pot = erro_aleatorio_medidor_pot/(3*100) # Tese da Livia + Orientação do prof Alex
        dp_padrao_tensao = erro_aleatorio_medidor_tensao/(3*100) # Tese da Livia + Orientação do prof Alex

        num_medidas = 0
        for idx, bus in enumerate(barras['nome_barra']):
            self.DSSCircuit.SetActiveBus(bus)
            fases = self.pegar_fases()
            barras.loc[[idx], 'Fases'] = pd.Series([fases], index=barras.index[[idx]])
            if not barras['Geracao'][idx]:
                barras.loc[[idx], 'Inj_pot_at'] = pd.Series([[0, 0, 0, 0]], index=barras.index[[idx]])
                barras.loc[[idx], 'Inj_pot_rat'] = pd.Series([[0, 0, 0, 0]], index=barras.index[[idx]])
                num_medidas += len(fases)*2
        
        #Amostra e salva os valores dos medidores do sistema
        self.DSSMonitors.SampleAll()
        self.DSSMonitors.SaveAll()

        self.DSSMonitors.First
        iter_random = 0
        for _ in range(self.DSSMonitors.Count):
            barra = self.DSSMonitors.Terminal - 1
            index_barra = self.achar_index_barra(barras, barra)
            
            #Pegar as fases da carga atual
            fases = self.DSSCircuit.ActiveCktElement.NodeOrder - 1
            fases = list(dict.fromkeys(fases))
            fases = [fase for fase in fases if fase != -1]
            matriz_medidas = self.DSSMonitors.AsMatrix()[0][2:]
            #print(self.DSSMonitors.Name)
            if 'pqij' in self.DSSMonitors.Name:
                if type(barras['Flux_pot_at'][index_barra]) != list and type(barras['Flux_pot_rat'][index_barra]) != list:
                    barras['Flux_pot_at'][index_barra] = []
                    barras['Flux_pot_rat'][index_barra] = []
                    
                elemento = self.DSSMonitors.Element
                self.DSSCircuit.ActiveCktElement.BusNames[1]
                medidas_at = np.full([3], np.NaN)
                medidas_rat = np.full([3], np.NaN)
                
                for i, fase in enumerate(fases):
                    medidas_at[fase] = matriz_medidas[i*2]*1000 / baseva
                    medidas_rat[fase] = matriz_medidas[i*2+1]*1000 / baseva
                    num_medidas += 2
                    
                barras['Flux_pot_at'][index_barra].append((elemento, medidas_at))
                barras['Flux_pot_rat'][index_barra].append((elemento, medidas_rat))
            
            elif 'pqi' in self.DSSMonitors.Name:
                fatores_pot = [1,1,1,1]
                if self.medidas_imperfeitas:
                    fatores_pot = np.random.normal(1, dp_padrao_pot, 4)
                    fatores_pot = np.clip(fatores_pot, 0.995, 1.005)
                medidas_at = np.zeros(4)
                medidas_rat = np.zeros(4)
                
                for i, fase in enumerate(fases):
                    medidas_at[fase] = matriz_medidas[i*2]
                    medidas_rat[fase] = matriz_medidas[i*2+1]

                # Multiplicar ponto a ponto por random de media 1 e 4 itens
                barras.loc[[index_barra], 'Inj_pot_at'] += pd.Series([(-medidas_at*1000 / baseva)*fatores_pot], index=barras.index[[index_barra]])
                barras.loc[[index_barra], 'Inj_pot_rat'] += pd.Series([(-medidas_rat*1000 / baseva)*fatores_pot], index=barras.index[[index_barra]])
                
            elif 'v' in self.DSSMonitors.Name:
                if type(barras['Tensao'][index_barra]) != np.ndarray:
                    medidas = np.zeros(4)
                    
                    for i, fase in enumerate(fases):
                        medidas[fase] = matriz_medidas[i]

                    basekv = self.DSSCircuit.Buses.kVBase

                    fatores_tensao = [1,1,1,1]
                    if self.medidas_imperfeitas:
                        fatores_tensao = np.random.normal(1, dp_padrao_tensao, 4)
                        fatores_tensao = np.clip(fatores_tensao, 0.995, 1.005)

                    barras.loc[[index_barra], 'Tensao'] = pd.Series([(medidas / (basekv*1000))*fatores_tensao], index=barras.index[[index_barra]])
                    if not barras['Geracao'][index_barra]:
                        num_medidas += len(fases)

            iter_random += 1
            self.DSSMonitors.Next
        
        return barras, num_medidas

    def medidas_anuais(self, baseva:int, total_horas:int) -> pd.DataFrame:
        # Configurações do OpenDSS para simulação anual
        self.DSSText.Command = "set stepsize=1h"
        self.DSSText.Command = "set mode=yearly"
        self.DSSText.Command = "set number=1"

        instante_inicial, num_medidas = self.medidas(baseva)

        # Lista das colunas a serem zeradas
        colunas_para_zerar = ['Inj_pot_at', 'Tensao', 'Inj_pot_rat']

        # Aplicar a função para zerar os valores das colunas especificadas
        for coluna in colunas_para_zerar:
            instante_inicial[coluna] = instante_inicial[coluna].apply(lambda x: {})

        num_medidas_anual = num_medidas*total_horas
        for h in range(total_horas):
            self.DSSCircuit.Solution.Solve()

            # Captura as medições para o instante atual
            instante_atual = self.medidas(baseva)[0]

            for i, values in instante_atual.iterrows():
                # Adiciona ou atualiza o dicionário na coluna 'Inj_pot_at' do instante_inicial
                instante_inicial.at[i, 'Inj_pot_at'][f'hora_{h}'] = values['Inj_pot_at']
                instante_inicial.at[i, 'Inj_pot_rat'][f'hora_{h}'] = values['Inj_pot_rat']
                instante_inicial.at[i, 'Tensao'][f'hora_{h}'] = values['Tensao']

            self.DSSMonitors.ResetAll()

        return instante_inicial, num_medidas_anual