O despacho de geração termoelétrica é um problema de otimização que visa equilibrar dois objetivos conflitantes: a minimização do custo operacional (custo de combustível) e a redução do impacto ambiental (emissões de poluentes). O Algoritmo de Otimização por Leão de Formigas (ALO), inspirado no mecanismo de caça desses insetos, apresenta um equilíbrio eficaz entre exploração global e busca local, tornando-se uma ferramenta adequada para abordar esta complexidade multiobjetivo.

Formulação do Problema e Etapas do Algoritmo

O problema é modelado com um conjunto de geradores, cada um com limites de potência mínima e máxima, e funções de custo que incluem termos não lineares, como o efeito de ponto de válvula. O ALO evolui uma população de soluções candidatas (formigas) em direção a um conjunto de soluções não-dominadas (a frente de Pareto).

1. Parâmetros Iniciais

# Definição dos parâmetros do algoritmo
num_insetos <- 60       # Tamanho da população
max_geracoes <- 120     # Número máximo de iterações
num_objetivos <- 2      # Funções objetivo (custo, emissões)
dim_problema <- 10      # Número de unidades geradoras

# Limites operacionais das unidades (MW)
limite_inf <- c(150, 200, 300, 100, 250, 200, 180, 190, 220, 280)
limite_sup <- c(500, 450, 600, 350, 550, 500, 420, 400, 480, 600)

2. Inicialização da População

# Geração aleatória das posições iniciais das formigas
populacao <- matrix(0, nrow = num_insetos, ncol = dim_problema)
for (i in 1:dim_problema) {
  populacao[, i] <- runif(num_insetos, limite_inf[i], limite_sup[i])
}

# Cópia inicial para os leões de formigas
leoes <- populacao

3. Avaliação e Ordenação Não-Dominada

# Função para calcular os objetivos
calcular_objetivos <- function(solucao) {
  # Coeficientes de custo quadratico e linear
  a <- c(0.002, 0.003, 0.001, ...)
  b <- c(15, 18, 20, ...)
  c0 <- c(500, 400, 600, ...)
  
  # Coeficientes de emissão
  alpha <- c(0.15, 0.18, 0.12, ...)
  beta <- c(0.5, 0.4, 0.6, ...)
  gamma <- c(10, 12, 8, ...)
  
  custo_total <- sum(a * solucao^2 + b * solucao + c0)
  emissao_total <- sum(alpha * solucao^2 + beta * solucao + gamma)
  
  return(c(custo_total, emissao_total))
}

# Avaliação de toda a população
matriz_objetivos <- t(apply(populacao, 1, calcular_objetivos))

# Realizar a classificação não-dominada (implementação simplificada)
# Retorna os ranks e as frentes
classificacao <- ordenacao_nao_dominada(matriz_objetivos)

4. Mecanismo de Captura e Movimento

# Identificação do leão de elite (melhor solução encontrada)
# Usando uma soma ponderada simples para selecionar um ponto de referência
pesos <- c(0.7, 0.3)
valores_ponderados <- apply(matriz_objetivos, 1, function(x) sum(pesos * x))
idx_elite <- which.min(valores_ponderados)
elite <- populacao[idx_elite, ]

# Movimento das formigas em direção ao leão de elite (espiral de captura)
nova_populacao <- matrix(0, nrow = num_insetos, ncol = dim_problema)
for (i in 1:num_insetos) {
  # Vetor de números aleatórios para controlar o passo
  r <- runif(dim_problema, -1, 1)
  # Movimento para a nova posição
  nova_populacao[i, ] <- populacao[i, ] + r * (elite - populacao[i, ])
  
  # Garantir que a nova posição respeite os limites
  nova_populacao[i, ] <- pmax(nova_populacao[i, ], limite_inf)
  nova_populacao[i, ] <- pmin(nova_populacao[i, ], limite_sup)
}

5. Atualização e Manutenção do Arquivo Externo

# Combinar soluções antigas e novas, e atualizar o arquivo de Pareto
arquivo_pareto <- rbind(arquivo_pareto, nova_populacao)
objetivos_arquivo <- t(apply(arquivo_pareto, 1, calcular_objetivos))

# Re-ordenar e filtrar o arquivo
classificacao_arquivo <- ordenacao_nao_dominada(objetivos_arquivo)

# Se o arquivo exceder o tamanho máximo, truncar usando distância de aglomeração
tam_max_arquivo <- 100
if (nrow(arquivo_pareto) > tam_max_arquivo) {
  indices_manter <- truncar_por_distancia(classificacao_arquivo, objetivos_arquivo, tam_max_arquivo)
  arquivo_pareto <- arquivo_pareto[indices_manter, ]
}

6. Processo Iterativo Principal

for (geracao in 1:max_geracoes) {
  # Atualizar as posições dos leões com base na média entre as formigas atuais e o elite
  for (i in 1:num_insetos) {
    leoes[i, ] <- (nova_populacao[i, ] + elite) / 2
  }
  
  # Avaliar a nova população e atualizar a frente de Pareto
  populacao <- nova_populacao
  matriz_objetivos <- t(apply(populacao, 1, calcular_objetivos))
  
  # Atualizar o elite e o arquivo externo
  # [Código omitido por brevidade]
}

Validação e Resultados Comparativos

A eficácia do ALO foi testada em sistemas-padrão da literatura. Os resultados demonstram convergência mais rápida para soluções de melhor compromisso em comparação com algoritmos genéticos (NSGA-II) e decomposição (MOEA/D). Para um sistema de 10 unidades geradoras, as métricas aproximadas foram:

Considerações Práticas e Extensões

Para aplicação em operações reais, o framework do ALO pode ser estendido para incluir despacho em múltiplos períodos, considerando a rampa de subida/descida das turbinas e custos de partida/parada. A incerteza na previsão de carga e na geração de fontes renováveis (eólica/solar) pode ser integrada através de técnicas de otimização robusta ou por cenários, onde o algoritmo busca soluções viáveis sob diferentes condições.

Funções Auxiliares Essenciais (Exemplo Simplificado)

# Função para determinar dominância entre dois vetores de objetivos
domina <- function(obj1, obj2) {
  # obj1 domina obj2 se for melhor ou igual em todos os objetivos e estritamente melhor em pelo menos um
  return(all(obj1 <= obj2) && any(obj1 < obj2))
}

# Função de ordenação não-dominada (retorna uma lista com as frentes)
ordenacao_nao_dominada <- function(matriz_objetivos) {
  n <- nrow(matriz_objetivos)
  contagem_dominancia <- rep(0, n)
  lista_dominados <- vector("list", n)
  frentes <- list()
  frente_atual <- c()
  
  for (i in 1:n) {
    for (j in 1:n) {
      if (i != j) {
        if (domina(matriz_objetivos[i, ], matriz_objetivos[j, ])) {
          lista_dominados[[i]] <- c(lista_dominados[[i]], j)
        } else if (domina(matriz_objetivos[j, ], matriz_objetivos[i, ])) {
          contagem_dominancia[i] <- contagem_dominancia[i] + 1
        }
      }
    }
    if (contagem_dominancia[i] == 0) {
      frente_atual <- c(frente_atual, i)
    }
  }
  frentes[[1]] <- frente_atual
  
  k <- 1
  while (length(frentes[[k]]) > 0) {
    proxima_frente <- c()
    for (i in frentes[[k]]) {
      for (j in lista_dominados[[i]]) {
        contagem_dominancia[j] <- contagem_dominancia[j] - 1
        if (contagem_dominancia[j] == 0) {
          proxima_frente <- c(proxima_frente, j)
        }
      }
    }
    k <- k + 1
    frentes[[k]] <- proxima_frente
  }
  
  # Calcular ranks a partir das frentes
  ranks <- rep(0, n)
  for (k in seq_along(frentes)) {
    for (idx in frentes[[k]]) {
      ranks[idx] <- k
    }
  }
  
  return(list(frentes = frentes, ranks = ranks))
}