monte_carlo_NS2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MONTE CARLO NÃO-SEQUENCIAL\n",
    "\n",
    "Trabalho de Confiabilidade de Sistemas Elétricos de Potência\n",
    "\n",
    "Alunos: \n",
    "\n",
    "Gabriel Halfeld\n",
    "\n",
    "Vinícius Albuquerque Cabral\n",
    "\n",
    "Data de entrega: 17/12/2024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMPORTAÇÃO DE BIBLIOTECAS\n",
    "\n",
    "Nesta seção, são importadas as bibliotecas necessárias para a realização das análises de confiabilidade. As principais bibliotecas utilizadas são:\n",
    "\n",
    "- `Pyomo`: Para modelagem e solução de problemas de otimização.\n",
    "- `pandas` (`pd`): Para manipulação e análise de dados tabulares.\n",
    "- `numpy` (`np`): Para operações matemáticas e computacionais.\n",
    "- `data_processing`: Um módulo personalizado para carregar os dados do sistema.\n",
    "- `calcula_fpo`: Um módulo personalizado para calcular os fluxos de potência.\n",
    "\n",
    "As bibliotecas externas são carregadas utilizando comandos `import`, enquanto os módulos customizados (localizados no diretório do projeto) são carregados diretamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyomo as pyo\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from data_processing import load_all_data\n",
    "from calcula_fpo import calcular_fpo\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LEITURA E PROCESSAMENTO DOS DADOS\n",
    "Nesta seção, os dados necessários para a análise de confiabilidade são carregados e processados. A estrutura geral envolve:\n",
    "\n",
    "- **`D_GEN`**: Dados relacionados aos geradores, incluindo taxas de falha, tempo de reparo e disponibilidade.\n",
    "- **`D_LIN`**: Dados das linhas de transmissão, considerando falhas por milha, comprimento das linhas e tempo de reparo.\n",
    "- **`D_LOAD`**: Informações sobre as cargas no sistema.\n",
    "\n",
    "Os dados carregados são normalizados para uso em análises temporais e de confiabilidade, incluindo a conversão de tempos e taxas para a escala de horas.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = load_all_data()\n",
    "D_GEN = data['D_GEN']\n",
    "D_LIN = data['D_LIN']\n",
    "D_LOAD = data['D_LOAD']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Deixando os dados em horas e nos formatos conhecidos\n",
    "#Dados de Geração\n",
    "D_GEN['Lambda'] = D_GEN['Falhas/ano'] / 8760 # 8760 horas em um ano\n",
    "D_GEN['MTTF'] = 1/D_GEN['Lambda'] #Tempo médio entre falhas\n",
    "D_GEN['mu'] = 1/D_GEN['Tempo de reparo(h)'] #Taxa de reparo/hora\n",
    "D_GEN['A'] = D_GEN['mu']/(D_GEN['mu'] + D_GEN['Lambda']) #Disponibilidade\n",
    "D_GEN['U'] = 1 - D_GEN['A'] #Indisponibilidade\n",
    "\n",
    "#Dados de Linha\n",
    "D_LIN['Lambda'] = D_LIN['Falhas/(ano.milha)'] * D_LIN['Comprimento'] / 8760 # 8760 horas em um ano\n",
    "D_LIN['MTTF'] = 1 / D_LIN['Lambda'] #Tempo médio entre falhas\n",
    "D_LIN['mu'] = 1 / D_LIN['Tempo de Reparo'] #Taxa de reparo/hora\n",
    "D_LIN['A'] = D_LIN['mu'] / (D_LIN['mu'] + D_LIN['Lambda']) #Disponibilidade\n",
    "D_LIN['U'] = 1 - D_LIN['A'] #Indisponibilidade\n",
    "\n",
    "#Numero de componentes\n",
    "Ng = len(D_GEN)\n",
    "Nl = len(D_LIN)\n",
    "Nc = len(D_LOAD)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ALGORITMO PRINCIPAL SMC NÃO-SEQUENCIAL\n",
    "O algoritmo de Monte Carlo Não-Sequencial (SMC-NS) é utilizado para simular o comportamento do sistema elétrico sem dependência temporal, levando em consideração falhas e reparos simultâneos de componentes, como geradores e linhas de transmissão. O objetivo é calcular índices de confiabilidade, como LOLP (Loss of Load Probability), EPNS (Expected Power Not Supplied), EENS (Energy Not Supplied), LOLE (Loss of Load Expectation), LOLD (Loss of Load Duration) e LOLF (Loss of Load Frequency).\n",
    "\n",
    "1. Variáveis de Controle para o Loop de Monte Carlo:\n",
    "NS: Contador de simulações realizadas.\n",
    "NSmax: Limite máximo de simulações (20000).\n",
    "beta: Convergência do LOLP (Loss of Load Probability).\n",
    "beta_tol: Tolerância do LOLP.\n",
    "beta_EPNS: Convergência do EPNS (Expected Power Not Supplied).\n",
    "beta_EPNS_tol: Tolerância do EPNS.\n",
    "São também inicializadas variáveis para acumular as somas de LOLP, EPNS e suas variâncias, a fim de calcular a convergência.\n",
    "\n",
    "2. Loop de Monte Carlo:\n",
    "O loop principal do SMC-NS é executado até que o número máximo de simulações (NSmax) seja atingido ou até que o LOLP e o EPNS atinjam a convergência desejada.\n",
    "- Geração de Sorteios Aleatórios: Para cada simulação, sorteios aleatórios são realizados para determinar o estado de falha de cada gerador e linha de transmissão:\n",
    "    - Estado dos Geradores: Para cada gerador, um sorteio é feito com base na taxa de falha do gerador (D_GEN['U'][i]).\n",
    "    - Estado das Linhas: Para cada linha de transmissão, um sorteio é feito com base na taxa de falha da linha (D_LIN['U'][i]).\n",
    "- Verificação de Perda de Carga: A função calcular_fpo é chamada para verificar se há perda de carga, isto é, se o corte (corte) é maior que zero.\n",
    "- Atualização do LOLP e EPNS: Se houver perda de carga, o LOLP e o EPNS são atualizados com base nas perdas de carga.\n",
    "- Sorteio de Tempos de Reparo: Para cada componente (geradores e linhas) que falhou, o tempo de reparo é sorteado a partir de uma distribuição exponencial, com taxa '1/mu = MTTR':\n",
    "    - O algoritmo escolhe o menor tempo de reparo entre os geradores e as linhas e realiza o reparo do componente correspondente. Após o reparo, o estado do componente é atualizado para \"operacional\" (1).\n",
    "    - Após cada reparo, o corte é recalculado para verificar se a perda de carga foi eliminada.\n",
    "    - O processo de sorteio de tempos de reparo é repetido até que não haja mais perda de carga e obtivermos o tempo de reparo da falha.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variáveis de controle para o loop de Monte Carlo\n",
    "NS = 0                     # Contador de simulações\n",
    "NSmax = 20000              # Limite de simulações\n",
    "\n",
    "beta = 10                  # Convergência de LOLP\n",
    "beta_tol = 0.01            # Tolerância de LOLP\n",
    "\n",
    "beta_EPNS = 10             # Convergência de EPNS\n",
    "beta_EPNS_tol = 0.02       # Tolerância de EPNS\n",
    "\n",
    "# Variáveis de acumulação para LOLP e EPNS\n",
    "SLOLP, SLOLP2 = 0, 0       # Somas de LOLP e quadrado\n",
    "SEPNS, SEPNS2 = 0, 0       # Somas de EPNS e quadrado\n",
    "\n",
    "tempo_falha_total = []\n",
    "\n",
    "# Loop de Monte Carlo\n",
    "while (beta >= beta_tol or beta_EPNS >= beta_EPNS_tol) and NS <= NSmax:\n",
    "    NS += 1\n",
    "    # Geração de sorteios aleatórios para geradores e linhas\n",
    "    sorteio_ger = np.random.rand(Ng)\n",
    "    sorteio_linhas =  np.random.rand(Nl)\n",
    "    estado_ger = [1 if sorteio_ger[i] > D_GEN['U'][i] else 0 for i in range(Ng)]\n",
    "    estado_linhas = [1 if sorteio_linhas[i] > D_LIN['U'][i] else 0 for i in range(Nl)]\n",
    "\n",
    "    # Verificação de perda de carga: Se corte > 0, há perda de carga\n",
    "    corte = calcular_fpo(estado_ger, estado_linhas, False)\n",
    "\n",
    "    if corte > 0:\n",
    "        #Atualização das somas do LOLP e EPNS\n",
    "        SLOLP += 1\n",
    "        SLOLP2 += 1**2\n",
    "        SEPNS += corte\n",
    "        SEPNS2 += corte**2\n",
    "\n",
    "        ger_falhos = [i for i in range(Ng) if estado_ger[i] == 0]\n",
    "        lin_falhos = [i for i in range(Nl) if estado_linhas[i] == 0]\n",
    "\n",
    "        # Sorteando o tempo de reparo para cada componente falho (exponencial com taxa mu)\n",
    "        tempos_reparo_geradores = {i: np.random.exponential(1/D_GEN['mu'][i]) for i in ger_falhos}\n",
    "        tempos_reparo_linhas = {i: np.random.exponential(1/D_LIN['mu'][i]) for i in lin_falhos}\n",
    "        tempo_falha = 0\n",
    "        \n",
    "        while corte > 0:\n",
    "            menor_tempo_ger = np.inf\n",
    "            menor_tempo_lin = np.inf\n",
    "            # Definindo o menor tempo de reparo e o componente correspondente\n",
    "            if tempos_reparo_geradores: # Verifica se o dicionário não está vazio\n",
    "                menor_tempo_ger = min(tempos_reparo_geradores.values())\n",
    "                componente_menor_tempo_ger = min(tempos_reparo_geradores, key=tempos_reparo_geradores.get)\n",
    "            if tempos_reparo_linhas: # Verifica se o dicionário não está vazio\n",
    "                menor_tempo_lin = min(tempos_reparo_linhas.values())\n",
    "                componente_menor_tempo_lin = min(tempos_reparo_linhas, key=tempos_reparo_linhas.get)\n",
    "\n",
    "            #Escolhendo o menor tempo de reparo:\n",
    "            if menor_tempo_ger < menor_tempo_lin:\n",
    "                tempo_falha = menor_tempo_ger\n",
    "                # Atualizar o estado do gerador e remover o tempo de reparo do dicionário\n",
    "                estado_ger[componente_menor_tempo_ger] = 1\n",
    "                del tempos_reparo_geradores[componente_menor_tempo_ger]\n",
    "            else:\n",
    "                tempo_falha = menor_tempo_lin\n",
    "                # Atualizar o estado da linha e remover o tempo de reparo do dicionário\n",
    "                estado_linhas[componente_menor_tempo_lin] = 1\n",
    "                del tempos_reparo_linhas[componente_menor_tempo_lin]\n",
    "            #Calcular o corte\n",
    "            corte = calcular_fpo(estado_ger, estado_linhas, False)\n",
    "        tempo_falha_total.append(tempo_falha)\n",
    "    \n",
    "    # Cálculo de convergência após 100 iterações\n",
    "    if NS > 100:\n",
    "        # Cálculo de LOLP e beta\n",
    "        ELOLP = SLOLP / NS\n",
    "        varLOLP = (SLOLP2 - NS * ELOLP**2) / (NS - 1)\n",
    "        varELOLP = varLOLP / NS\n",
    "        beta = np.sqrt(varELOLP) / ELOLP if ELOLP != 0 else 0\n",
    "\n",
    "        # Cálculo de EPNS e beta_EPNS\n",
    "        EPNS = SEPNS / NS\n",
    "        varEPNS = (SEPNS2 - NS * EPNS**2) / (NS - 1)\n",
    "        varEPNS = varEPNS / NS\n",
    "        beta_EPNS = np.sqrt(varEPNS) / EPNS if EPNS != 0 else 0\n",
    "\n",
    "#Obtenção do EPNS:\n",
    "EPNS_MC = EPNS\n",
    "#Obtenção do LOLP:\n",
    "LOLP_MC = ELOLP\n",
    "#Cálculo do EENS:\n",
    "EENS_MC = EPNS * 8760\n",
    "#Cálculo do LOLE:\n",
    "LOLE_MC = 8760 * LOLP_MC\n",
    "#Cálculo do LOLD:\n",
    "LOLD_MC = sum(tempo_falha_total)/len(tempo_falha_total)\n",
    "#Cálculo do LOLF:\n",
    "LOLF_MC = LOLE_MC / LOLD_MC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RESULTADOS\n",
    "Nesta seção, os resultados obtidos serão apresentados:\n",
    "- **LOLP (Loss of Load Probability)**\n",
    "- **LOLE (Loss of Load Expectation)**\n",
    "- **LOLF (Loss of Load Frequency)**\n",
    "- **EENS (Expected Energy Not Supplied)**\n",
    "- **EPNS (Expected Power Not Supplied)**\n",
    "- **LOLD (Loss of Load Duration)**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected Energy Not Supplied (EENS): 56.43 GWh/ano\n",
      "Expected Power Not Supplied (EPNS): 6.44 MW\n",
      "Loss of Load Duration (LOLD): 33.64 horas/eventos de corte\n",
      "Loss of Load Expectation (LOLE): 800.19 horas/ano\n",
      "Loss of Load Probability (LOLP): 9.13  %\n",
      "Loss of Load Frequency (LOLF): 23.79 eventos de corte/ano\n",
      "Tempo de Execução: 19m 9.8s\n"
     ]
    }
   ],
   "source": [
    "# Print dos Resultados:\n",
    "print(f\"Expected Energy Not Supplied (EENS): {EENS_MC/1000:.2f} GWh/ano\")\n",
    "print(f\"Expected Power Not Supplied (EPNS): {EPNS_MC:.2f} MW\")\n",
    "print(f\"Loss of Load Duration (LOLD): {LOLD_MC:.2f} horas/eventos de corte\")\n",
    "print(f\"Loss of Load Expectation (LOLE): {LOLE_MC:.2f} horas/ano\")\n",
    "print(f\"Loss of Load Probability (LOLP): {LOLP_MC*100:.2f}  %\")\n",
    "print(f\"Loss of Load Frequency (LOLF): {LOLF_MC:.2f} eventos de corte/ano\")\n",
    "print('Tempo de Execução: 19m 9.8s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outra forma de definir o LOLD e LOLF\n",
    "\n",
    "Uma outra abordagem para definir o LOLD é utilizando os valores determinísticos do MTTR de todos os componentes falhos e escolher o maior valor, ou seja, o maior tempo de reparo. Dessa forma, fazemos uma aproximação do tempo de reparo para o reparo de todos os componentes falhos, diferentemente do que fizemos anteriormente, em que reparávamos um componente por vez e verificávamos a perda de carga em cada reparo. Além disso, anteriormente faziamos uma amostragem do tempo de reparo com uma distribuição exponencial, enquanto que agora nos baseamos com os valores determinísticos do MTTR.\n",
    "\n",
    "Essa abordagem reduz o tempo computacional, mas superestima o LOLD e, em compensação, subestima o LOLF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 0.09822899851704987\n",
      "2000 0.07112196089877565\n",
      "3000 0.056802920352788736\n"
     ]
    }
   ],
   "source": [
    "tic = time.time()\n",
    "\n",
    "Ncenarios = 1000000\n",
    "\n",
    "#  0        1         2                3       4      5        6       7       8         9               10\n",
    "# LOLP | ELOLP | SOMATORIO ELOLP^2 | EPNS | EEPNS | LOLE  | ELOLE | EENS  | EEENS | SOMATORIO EENS^2 | mu_estado\n",
    "MATRIZ_CENARIOS = np.zeros((Ncenarios,10))\n",
    "\n",
    "# Vai armazenar os valores de cada índice Beta\n",
    "BETA = np.zeros((Ncenarios,))\n",
    "\n",
    "beta = 1\n",
    "icen = -1\n",
    "conta_indisp = 0\n",
    "\n",
    "while beta > 5/100 and icen < Ncenarios-1:\n",
    "\n",
    "    icen += 1\n",
    "    \n",
    "    # Gera o estado\n",
    "    sorteio_ger = np.random.rand(Ng)\n",
    "    sorteio_lin = np.random.rand(Nl)\n",
    "\n",
    "    GER_ON = np.array(D_GEN['U']) <= sorteio_ger\n",
    "    LIN_ON = np.array(D_LIN['U']) <= sorteio_lin\n",
    "\n",
    "    GER_ON = GER_ON.astype(int)\n",
    "    LIN_ON = LIN_ON.astype(int)\n",
    "\n",
    "    corte = calcular_fpo(GER_ON, LIN_ON, False)\n",
    "    \n",
    "    tempo_reparo_sistema = np.max([np.max((1-GER_ON)*D_GEN['Tempo de reparo(h)']), np.max((1-LIN_ON)*D_LIN['Tempo de Reparo'])])\n",
    "\n",
    "    if corte > 0:\n",
    "\n",
    "        MATRIZ_CENARIOS[icen,0] = 1\n",
    "        MATRIZ_CENARIOS[icen,5] = tempo_reparo_sistema\n",
    "\n",
    "    MATRIZ_CENARIOS[icen,3] = corte\n",
    "\n",
    "    # Construção do índice ELOLP e EEPNS\n",
    "    if icen == 0:\n",
    "        MATRIZ_CENARIOS[icen,1] = MATRIZ_CENARIOS[icen,0]\n",
    "        MATRIZ_CENARIOS[icen,4] = MATRIZ_CENARIOS[icen,3]\n",
    "    else:\n",
    "        MATRIZ_CENARIOS[icen,1] = np.sum(MATRIZ_CENARIOS[:icen+1,0])/(icen+1)\n",
    "        MATRIZ_CENARIOS[icen,4] = np.sum(MATRIZ_CENARIOS[:icen+1,3])/(icen+1)\n",
    "    \n",
    "    # Construção do índice ELOLP^2\n",
    "    if icen == 0:\n",
    "        MATRIZ_CENARIOS[icen,2] = MATRIZ_CENARIOS[icen,0]\n",
    "    else:\n",
    "        MATRIZ_CENARIOS[icen,2] = np.sum(MATRIZ_CENARIOS[:icen+1,0]**2)\n",
    "\n",
    "    if icen > 0:\n",
    "\n",
    "        # Variância da função\n",
    "        var_fun = (MATRIZ_CENARIOS[icen,2] - (icen+1)*MATRIZ_CENARIOS[icen,1]**2)/icen\n",
    "\n",
    "        # Variância do valor esperado\n",
    "        var_esp = var_fun/(icen+1)\n",
    "\n",
    "        desvio_padrao_valor_esperado = np.sqrt(var_esp)\n",
    "\n",
    "        beta = desvio_padrao_valor_esperado/(MATRIZ_CENARIOS[icen,1]+0.0000000001)\n",
    "\n",
    "        if beta == 0:\n",
    "\n",
    "            beta = 1\n",
    "\n",
    "        if icen % 1000 == 0:\n",
    "\n",
    "            print(icen,beta)\n",
    "\n",
    "        BETA[icen] = beta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LOLP - LOSS OF LOAD PROBABILITY\n",
      "Probabilidade de ocorrência de perda de carga\n",
      "O LOLP é calculado através da divisão da quantidade de cenários em que há perda de carga pela quantidade total de cenários:\n",
      "LOLP: 9.57 %\n",
      "----------------------------------------------\n",
      "LOLE - LOSS OF LOAD EXPECTATION\n",
      "É o tempo médio esperado em que não haverá atendimento da carga do sistema.\n",
      "O LOLE é calculado através da multiplicação :\n",
      "LOLE: 838.48 h\n",
      "----------------------------------------------\n",
      "EPNS - EXPECTED POWER NOT SUPPLIED\n",
      "Valor experado da carga não atendida, em MW.\n",
      "EPNS: 6.7 MW\n",
      "----------------------------------------------\n",
      "EENS - EXPECTED ENERGY NOT SUPPLIED\n",
      "Valor experado da energia não atendida, em MWh.\n",
      "EENS: 58690.7 MWh\n",
      "----------------------------------------------\n",
      "LOLD - LOSS OF LOAD DURATION\n",
      "Duração média da perda de carga.\n",
      "Pela definição, o LOLD é a razão entre o LOLP e o LOLF.\n",
      "LOLD: 85.69 h\n",
      "----------------------------------------------\n",
      "LOLF - LOSS OF LOAD FREQUENCY\n",
      "É a frequência média de perda de carga definida como falhas/período\n",
      "O LOLF é calculado através da divisão da soma das taxas de reparos dos cenários em que há perda de carga pela quantidade de cenários:\n",
      "LOLF: 9.78 falhas/ano\n",
      "----------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "MATRIZ_CENARIOS = MATRIZ_CENARIOS[:icen+1,:]\n",
    "\n",
    "# Cálculo do LOLP do sistema\n",
    "LOLP_MC = MATRIZ_CENARIOS[-1,1]\n",
    "print('LOLP - LOSS OF LOAD PROBABILITY')\n",
    "print('Probabilidade de ocorrência de perda de carga')\n",
    "print('O LOLP é calculado através da divisão da quantidade de cenários em que há perda de carga pela quantidade total de cenários:')\n",
    "print('LOLP:',np.round(LOLP_MC*100,2),'%')\n",
    "print('----------------------------------------------')\n",
    "\n",
    "# Cálculo do LOLE do sistema\n",
    "LOLE_MC = LOLP_MC*8760\n",
    "print('LOLE - LOSS OF LOAD EXPECTATION')\n",
    "print('É o tempo médio esperado em que não haverá atendimento da carga do sistema.')\n",
    "print('O LOLE é calculado através da multiplicação :')\n",
    "print('LOLE:',np.round(LOLE_MC,2),'h')\n",
    "print('----------------------------------------------')\n",
    "\n",
    "# Cálculo do EPNS do sistema\n",
    "EPNS_MC = np.sum(MATRIZ_CENARIOS[:,4])/(icen+1)\n",
    "print('EPNS - EXPECTED POWER NOT SUPPLIED')\n",
    "print('Valor experado da carga não atendida, em MW.')\n",
    "print('EPNS:',np.round(EPNS_MC,2),'MW')\n",
    "print('----------------------------------------------')\n",
    "\n",
    "# Cálculo do EENS do sistema\n",
    "EENS_MC = EPNS_MC*8760\n",
    "print('EENS - EXPECTED ENERGY NOT SUPPLIED')\n",
    "print('Valor experado da energia não atendida, em MWh.')\n",
    "print('EENS:',np.round(EENS_MC,2),'MWh')\n",
    "print('----------------------------------------------')\n",
    "\n",
    "# Cálculo do LOLD do sistema\n",
    "LOLD_MC = np.sum(MATRIZ_CENARIOS[:,5])/sum(MATRIZ_CENARIOS[:,0])\n",
    "print('LOLD - LOSS OF LOAD DURATION')\n",
    "print('Duração média da perda de carga.')\n",
    "print('Pela definição, o LOLD é a razão entre o LOLP e o LOLF.')\n",
    "print('LOLD:',np.round(LOLD_MC,2),'h')\n",
    "print('----------------------------------------------')\n",
    "\n",
    "# Cálculo do LOLF do sistema\n",
    "LOLF_MC = LOLP_MC/LOLD_MC*8760\n",
    "print('LOLF - LOSS OF LOAD FREQUENCY')\n",
    "print('É a frequência média de perda de carga definida como falhas/período')\n",
    "print('O LOLF é calculado através da divisão da soma das taxas de reparos dos cenários em que há perda de carga pela quantidade de cenários:')\n",
    "print('LOLF:',np.round(LOLF_MC,2),'falhas/ano')\n",
    "print('----------------------------------------------')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}