From c588f05c1affa7b3ccd649d176b92d48f5b1de0f Mon Sep 17 00:00:00 2001 From: Luciano Silva do Lago Date: Sun, 7 Jun 2026 21:02:57 -0300 Subject: [PATCH] feat: adiciona Modelos 7, 8 e 9 para resolver problema com mix de frota C-97 e C-99 e demanda unificada --- create_nb.py | 254 ++++++++++++++++ modelos.ipynb | 786 ++++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 922 insertions(+), 118 deletions(-) diff --git a/create_nb.py b/create_nb.py index ca1389d..eb921ec 100644 --- a/create_nb.py +++ b/create_nb.py @@ -858,6 +858,260 @@ while voos_para_fazer_c99_6: print(tabulate(tabela_horarios_c99_6, headers=["Aeronave", "Origem", "Destino", "Tipo", "Partida", "Chegada", "Duração"], tablefmt="github")) """)) + +# ========================================== +# SEÇÃO MIX C-97 + C-99A +# ========================================== +cells.append(nbf.v4.new_markdown_cell("""# Alocação de Frotas - Mix (C-97 + C-99A) +Agora vamos analisar a demanda de forma unificada (soma dos passageiros transportados por C-97 e C-99A) e colocar as duas frotas para trabalhar em conjunto nos Modelos 7, 8 e 9. +""")) + +cells.append(nbf.v4.new_code_cell("""# 1. Filtro e Limpeza Unificados (Mix) +df_mix = df[df['Modelo'].isin(['C-97', 'C-99A'])].copy() +df_mix = df_mix[df_mix['Localidade Decolagem'] != 0] +df_mix = df_mix[df_mix['Localidade Pouso'] != 0] +df_mix['Trecho'] = df_mix['Localidade Decolagem'] + '-' + df_mix['Localidade Pouso'] +df_mix['PAX'] = pd.to_numeric(df_mix['PAX']).fillna(0) +df_mix['Dep TimeStamp'] = pd.to_datetime(df_mix['Data de Decolagem'] + ' ' + df_mix['Hora de Decolagem'], format='mixed', dayfirst=True) +df_mix['Data Apenas'] = df_mix['Dep TimeStamp'].dt.date + +# Demanda diária +demanda_diaria_mix = df_mix.groupby(['Trecho', 'Data Apenas'])['PAX'].sum().reset_index() + +todos_trechos_mix = demanda_diaria_mix['Trecho'].unique() +idx_mix = pd.MultiIndex.from_product([todos_trechos_mix, datas_2025], names=['Trecho', 'Data Apenas']) +demanda_diaria_completa_mix = pd.DataFrame(index=idx_mix).reset_index() +demanda_diaria_completa_mix = pd.merge(demanda_diaria_completa_mix, demanda_diaria_mix, on=['Trecho', 'Data Apenas'], how='left').fillna({'PAX': 0}) + +estatisticas_trechos_mix = demanda_diaria_completa_mix.groupby('Trecho').agg( + Total_PAX=('PAX', 'sum'), + Dias_Operados=('PAX', lambda x: (x > 0).sum()) +).reset_index() + +estatisticas_trechos_mix['Media_PAX_Dias_Operados'] = estatisticas_trechos_mix.apply( + lambda row: row['Total_PAX'] / row['Dias_Operados'] if row['Dias_Operados'] > 0 else 0, axis=1 +) +estatisticas_trechos_mix['Score_Relevancia'] = estatisticas_trechos_mix['Total_PAX'] * estatisticas_trechos_mix['Dias_Operados'] +estatisticas_trechos_mix = estatisticas_trechos_mix.sort_values(by='Score_Relevancia', ascending=False) + +NUM_TRECHOS_MIX = 10 +top_trechos_mix = estatisticas_trechos_mix.head(NUM_TRECHOS_MIX) + +display(top_trechos_mix) + +plt.figure(figsize=(10, 6)) +sns.barplot(data=top_trechos_mix, x='Trecho', y='Score_Relevancia', hue='Trecho', palette='cubehelix', legend=False) +plt.title(f'Top {NUM_TRECHOS_MIX} Trechos MIX (C-97 + C-99A)') +plt.xticks(rotation=45) +plt.tight_layout() +plt.show() + +# Rede Mix +G_mix = nx.DiGraph() +for _, row in top_trechos_mix.iterrows(): + origem, destino = row['Trecho'].split('-') + G_mix.add_edge(origem, destino, weight=row['Score_Relevancia']) +pos_mix = nx.spring_layout(G_mix, k=2.5, iterations=100, seed=42) +plt.figure(figsize=(12, 8)) +nx.draw_networkx_nodes(G_mix, pos_mix, node_size=1200, node_color='plum', edgecolors='black') +nx.draw_networkx_edges(G_mix, pos_mix, edgelist=G_mix.edges(), arrows=True, arrowstyle='-|>', arrowsize=25, edge_color='gray', width=2, node_size=1200, connectionstyle='arc3,rad=0.15') +nx.draw_networkx_labels(G_mix, pos_mix, font_size=12, font_weight='bold') +plt.title('Diagrama de Rede - Unificada', fontsize=14) +plt.axis('off') +plt.show() +""")) + +cells.append(nbf.v4.new_markdown_cell("""## MODELO 7: Minimização de Distância (Custo) com Mix de Frota +A malha será atendida pelas duas aeronaves. O modelo decide quem alocar para cobrir a **demanda em passageiros** de cada rota, visando minimizar o número total de voos * distância (simplificação de custo de combustível), e não exceder o tamanho da frota física de cada modelo. +""")) + +cells.append(nbf.v4.new_code_cell("""# Preparação Modelo 7 +rotas_lista_mix = top_trechos_mix['Trecho'].tolist() + +distancias_voo_mix = {} +for r in rotas_lista_mix: + origem, destino = r.split('-') + distancias_voo_mix[r] = calc_distancia(origem, destino) + +demanda_pax_mix = {} +for _, row in top_trechos_mix.iterrows(): + demanda_pax_mix[row['Trecho']] = row['Media_PAX_Dias_Operados'] + +prob7 = pulp.LpProblem("Fleet_Assignment_Mix_Brasil", pulp.LpMinimize) + +X_97 = pulp.LpVariable.dicts("X_97", rotas_lista_mix, lowBound=0, cat='Integer') +X_99 = pulp.LpVariable.dicts("X_99", rotas_lista_mix, lowBound=0, cat='Integer') + +# Minimizar distância combinada +prob7 += pulp.lpSum([distancias_voo_mix[r] * (X_97[r] + X_99[r]) for r in rotas_lista_mix]) + +# Restrição de demanda (Em PAX) +for r in rotas_lista_mix: + prob7 += (X_97[r] * CAPACIDADE_C97) + (X_99[r] * CAPACIDADE_C99) >= demanda_pax_mix[r] + +# Restrição de uso da frota global para o dia (simplificado a 1 perna por aeronave aqui) +prob7 += pulp.lpSum([X_97[r] for r in rotas_lista_mix]) <= total_aeronaves +prob7 += pulp.lpSum([X_99[r] for r in rotas_lista_mix]) <= total_aeronaves_c99 + +prob7.solve(pulp.PULP_CBC_CMD(msg=False)) + +print("== MODELO 7 (MIX C-97 e C-99A) ==") +print(f"Status: {pulp.LpStatus[prob7.status]}") +print(f"Distância Total da Operação Combinada: {pulp.value(prob7.objective):.2f} km\\n") + +for r in rotas_lista_mix: + c97_alloc = int(X_97[r].varValue) + c99_alloc = int(X_99[r].varValue) + capacidade_gerada = (c97_alloc * CAPACIDADE_C97) + (c99_alloc * CAPACIDADE_C99) + print(f"Trecho: {r:10} | Demanda PAX: {demanda_pax_mix[r]:.0f} | Oferecido: {capacidade_gerada} | Alocados -> C-97: {c97_alloc}, C-99A: {c99_alloc}") +""")) + + +cells.append(nbf.v4.new_markdown_cell("""## MODELO 8: Minimização Absoluta de Frota Mix (S/ TAT) +Diferente do Modelo 7, permitimos ciclos completos (vários voos por aeronave no dia) para minimizar a quantidade real de fuselagens exigidas para a operação. O modelo fará os reposicionamentos vazios necessários e alocará o voo ao tipo ideal. +""")) + +cells.append(nbf.v4.new_code_cell("""# Malha Aeroportuária +aeroportos_malha_mix = set() +for r in rotas_lista_mix: + o, d = r.split('-') + aeroportos_malha_mix.add(o) + aeroportos_malha_mix.add(d) +aeroportos_malha_mix = list(aeroportos_malha_mix) + +# Matrizes de tempo exclusivas de cada aeronave na malha mix +t_voo_97 = {} +t_voo_99 = {} +for o in aeroportos_malha_mix: + for d in aeroportos_malha_mix: + if o == d: + t_voo_97[(o, d)] = 0 + t_voo_99[(o, d)] = 0 + else: + dist = calc_distancia(o, d) + t_voo_97[(o, d)] = int(round((dist / vel_media_c97) * 60)) + t_voo_99[(o, d)] = int(round((dist / vel_media_c99) * 60)) + +prob8 = pulp.LpProblem("Minimizar_Frota_Mix", pulp.LpMinimize) + +# D = Voos de Demanda (agora variável) +D_97 = pulp.LpVariable.dicts("D_97", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') +D_99 = pulp.LpVariable.dicts("D_99", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') + +# Y = Voos de Reposicionamento Vazios +Y_97 = pulp.LpVariable.dicts("Y_97", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') +Y_99 = pulp.LpVariable.dicts("Y_99", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') + +N_97 = pulp.LpVariable("N_97", lowBound=0, cat='Integer') +N_99 = pulp.LpVariable("N_99", lowBound=0, cat='Integer') + +# Objetivo: Minimizar a soma de aeronaves. +# Adicionamos pequenas penalidades para desempate: +# 1. Preferir tempo de voo menor nos reposicionamentos +# 2. C-99 é mais cara/maior, penalidade irrisória para preferir C-97 se ambas puderem (custo indireto) +penalidade_voo_97 = pulp.lpSum([(D_97[(i, j)] + Y_97[(i, j)]) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) +penalidade_voo_99 = pulp.lpSum([(D_99[(i, j)] + Y_99[(i, j)]) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) +prob8 += N_97 + N_99 + 0.001 * N_99 + 0.00001 * (penalidade_voo_97 + penalidade_voo_99) + +# Restrição de Demanda em PAX +# Todas as rotas que não são Top10 tem demanda = 0 +for i in aeroportos_malha_mix: + for j in aeroportos_malha_mix: + r_name = f"{i}-{j}" + demanda = demanda_pax_mix.get(r_name, 0) + prob8 += (D_97[(i, j)] * CAPACIDADE_C97) + (D_99[(i, j)] * CAPACIDADE_C99) >= demanda + +# Restrições de Fluxo Circulares (separados por tipo) +for no in aeroportos_malha_mix: + # C-97 + chegadas_97 = pulp.lpSum([D_97[(i, no)] + Y_97[(i, no)] for i in aeroportos_malha_mix]) + partidas_97 = pulp.lpSum([D_97[(no, j)] + Y_97[(no, j)] for j in aeroportos_malha_mix]) + prob8 += chegadas_97 == partidas_97 + + # C-99 + chegadas_99 = pulp.lpSum([D_99[(i, no)] + Y_99[(i, no)] for i in aeroportos_malha_mix]) + partidas_99 = pulp.lpSum([D_99[(no, j)] + Y_99[(no, j)] for j in aeroportos_malha_mix]) + prob8 += chegadas_99 == partidas_99 + +# Restrições de tempo operacional diário +prob8 += pulp.lpSum([(D_97[(i, j)] + Y_97[(i, j)]) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_97 * 1440 +prob8 += pulp.lpSum([(D_99[(i, j)] + Y_99[(i, j)]) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_99 * 1440 + +# Restrições Físicas +prob8 += N_97 <= total_aeronaves +prob8 += N_99 <= total_aeronaves_c99 + +prob8.solve(pulp.PULP_CBC_CMD(msg=False)) + +print("\\n== RESULTADO DO MODELO 8 (MIX SEM TAT) ==") +print(f"Status: {pulp.LpStatus[prob8.status]}") +print(f"Aeronaves C-97 necessárias: {int(N_97.varValue)}") +print(f"Aeronaves C-99A necessárias: {int(N_99.varValue)}") +print(f"Frota total mobilizada: {int(N_97.varValue) + int(N_99.varValue)} aeronaves\\n") + +print("Alocações para satisfazer a Demanda:") +for r in rotas_lista_mix: + origem, destino = r.split('-') + d97_val = int(D_97[(origem, destino)].varValue) + d99_val = int(D_99[(origem, destino)].varValue) + print(f" -> Trecho {r:10}: C-97 faz {d97_val} voo(s) | C-99A faz {d99_val} voo(s)") +""")) + +cells.append(nbf.v4.new_markdown_cell("""## MODELO 9: Minimização Absoluta de Frota Mix (C/ TAT 40 MIN) +Por fim, a versão que soma a demanda, usa as duas frotas simultaneamente, permite múltiplos voos por dia, gera reposicionamentos e pune **40 minutos** no chão (TAT) para cada perna voada por qualquer um dos aviões. +""")) + +cells.append(nbf.v4.new_code_cell("""# Modelo 9 +prob9 = pulp.LpProblem("Minimizar_Frota_Mix_TAT", pulp.LpMinimize) + +D_97_t = pulp.LpVariable.dicts("D_97t", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') +D_99_t = pulp.LpVariable.dicts("D_99t", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') +Y_97_t = pulp.LpVariable.dicts("Y_97t", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') +Y_99_t = pulp.LpVariable.dicts("Y_99t", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer') + +N_97_t = pulp.LpVariable("N_97t", lowBound=0, cat='Integer') +N_99_t = pulp.LpVariable("N_99t", lowBound=0, cat='Integer') + +TAT_min = 40 + +penalidade_97 = pulp.lpSum([(D_97_t[(i, j)] + Y_97_t[(i, j)]) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) +penalidade_99 = pulp.lpSum([(D_99_t[(i, j)] + Y_99_t[(i, j)]) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) +prob9 += N_97_t + N_99_t + 0.001 * N_99_t + 0.00001 * (penalidade_97 + penalidade_99) + +for i in aeroportos_malha_mix: + for j in aeroportos_malha_mix: + r_name = f"{i}-{j}" + demanda = demanda_pax_mix.get(r_name, 0) + prob9 += (D_97_t[(i, j)] * CAPACIDADE_C97) + (D_99_t[(i, j)] * CAPACIDADE_C99) >= demanda + +for no in aeroportos_malha_mix: + prob9 += pulp.lpSum([D_97_t[(i, no)] + Y_97_t[(i, no)] for i in aeroportos_malha_mix]) == pulp.lpSum([D_97_t[(no, j)] + Y_97_t[(no, j)] for j in aeroportos_malha_mix]) + prob9 += pulp.lpSum([D_99_t[(i, no)] + Y_99_t[(i, no)] for i in aeroportos_malha_mix]) == pulp.lpSum([D_99_t[(no, j)] + Y_99_t[(no, j)] for j in aeroportos_malha_mix]) + +# TAT INCLUSO AQUI +prob9 += pulp.lpSum([(D_97_t[(i, j)] + Y_97_t[(i, j)]) * (t_voo_97[(i, j)] + TAT_min) for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_97_t * 1440 +prob9 += pulp.lpSum([(D_99_t[(i, j)] + Y_99_t[(i, j)]) * (t_voo_99[(i, j)] + TAT_min) for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_99_t * 1440 + +prob9 += N_97_t <= total_aeronaves +prob9 += N_99_t <= total_aeronaves_c99 + +prob9.solve(pulp.PULP_CBC_CMD(msg=False)) + +print("\\n== RESULTADO DO MODELO 9 (MIX COM 40 MIN TAT) ==") +print(f"Status: {pulp.LpStatus[prob9.status]}") +print(f"Aeronaves C-97 necessárias: {int(N_97_t.varValue)}") +print(f"Aeronaves C-99A necessárias: {int(N_99_t.varValue)}") +print(f"Frota total mobilizada: {int(N_97_t.varValue) + int(N_99_t.varValue)} aeronaves\\n") + +tempo_97_voo = sum([(int(D_97_t[(i, j)].varValue) + int(Y_97_t[(i, j)].varValue)) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) +tempo_99_voo = sum([(int(D_99_t[(i, j)].varValue) + int(Y_99_t[(i, j)].varValue)) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) + +total_voos = sum([(int(D_97_t[(i, j)].varValue) + int(Y_97_t[(i, j)].varValue) + int(D_99_t[(i, j)].varValue) + int(Y_99_t[(i, j)].varValue)) for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) + +print(f"Tempo total de voo da frota combinada: {tempo_97_voo + tempo_99_voo} min ({(tempo_97_voo + tempo_99_voo)/60:.2f} h)") +print(f"Tempo de solo desperdiçado (TAT 40 min em {total_voos} voos): {total_voos * TAT_min} min ({(total_voos * TAT_min)/60:.2f} h)") +""")) + nb.cells = cells with open('modelos.ipynb', 'w', encoding='utf-8') as f: diff --git a/modelos.ipynb b/modelos.ipynb index 34b8c11..566c177 100644 --- a/modelos.ipynb +++ b/modelos.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "f5ec4bcf", + "id": "3da11ed7", "metadata": {}, "source": [ "# Alocação de Frotas (Fleet Scheduling) - Aeronaves C-97\n", @@ -21,13 +21,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "6697b12b", + "id": "fb50d855", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:33.054677Z", - "iopub.status.busy": "2026-06-07T23:57:33.054015Z", - "iopub.status.idle": "2026-06-07T23:57:33.693276Z", - "shell.execute_reply": "2026-06-07T23:57:33.690940Z" + "iopub.execute_input": "2026-06-08T00:02:51.803288Z", + "iopub.status.busy": "2026-06-08T00:02:51.802770Z", + "iopub.status.idle": "2026-06-08T00:02:52.524042Z", + "shell.execute_reply": "2026-06-08T00:02:52.523223Z" } }, "outputs": [], @@ -53,7 +53,7 @@ }, { "cell_type": "markdown", - "id": "78257a48", + "id": "8f4cd9a7", "metadata": {}, "source": [ "## 1. Leitura e Limpeza dos Dados\n", @@ -63,13 +63,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "aa079637", + "id": "3404c328", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:33.695046Z", - "iopub.status.busy": "2026-06-07T23:57:33.694816Z", - "iopub.status.idle": "2026-06-07T23:57:34.087298Z", - "shell.execute_reply": "2026-06-07T23:57:34.086363Z" + "iopub.execute_input": "2026-06-08T00:02:52.525891Z", + "iopub.status.busy": "2026-06-08T00:02:52.525587Z", + "iopub.status.idle": "2026-06-08T00:02:52.935903Z", + "shell.execute_reply": "2026-06-08T00:02:52.935382Z" } }, "outputs": [], @@ -101,7 +101,7 @@ }, { "cell_type": "markdown", - "id": "06d31f16", + "id": "c8fb80a2", "metadata": {}, "source": [ "## 2. Análise dos Esquadrões e Matrículas (Aeronaves)\n", @@ -111,13 +111,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "336f2956", + "id": "142209ce", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:34.088770Z", - "iopub.status.busy": "2026-06-07T23:57:34.088637Z", - "iopub.status.idle": "2026-06-07T23:57:34.101734Z", - "shell.execute_reply": "2026-06-07T23:57:34.101186Z" + "iopub.execute_input": "2026-06-08T00:02:52.937763Z", + "iopub.status.busy": "2026-06-08T00:02:52.937622Z", + "iopub.status.idle": "2026-06-08T00:02:52.952282Z", + "shell.execute_reply": "2026-06-08T00:02:52.951703Z" } }, "outputs": [ @@ -176,7 +176,7 @@ }, { "cell_type": "markdown", - "id": "339dec26", + "id": "f845c354", "metadata": {}, "source": [ "## 3. Análise Estatística das Demandas Diárias\n", @@ -187,13 +187,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "016363d5", + "id": "1fe88a0f", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:34.103227Z", - "iopub.status.busy": "2026-06-07T23:57:34.103108Z", - "iopub.status.idle": "2026-06-07T23:57:34.429121Z", - "shell.execute_reply": "2026-06-07T23:57:34.428557Z" + "iopub.execute_input": "2026-06-08T00:02:52.953810Z", + "iopub.status.busy": "2026-06-08T00:02:52.953679Z", + "iopub.status.idle": "2026-06-08T00:02:53.281444Z", + "shell.execute_reply": "2026-06-08T00:02:53.280808Z" } }, "outputs": [ @@ -424,7 +424,7 @@ }, { "cell_type": "markdown", - "id": "3c77b9ad", + "id": "d3fcb682", "metadata": {}, "source": [ "## Diagrama de Rede dos Trechos\n", @@ -434,13 +434,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "cf0a41c4", + "id": "ab894f9d", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:34.430584Z", - "iopub.status.busy": "2026-06-07T23:57:34.430456Z", - "iopub.status.idle": "2026-06-07T23:57:34.558385Z", - "shell.execute_reply": "2026-06-07T23:57:34.555014Z" + "iopub.execute_input": "2026-06-08T00:02:53.282929Z", + "iopub.status.busy": "2026-06-08T00:02:53.282778Z", + "iopub.status.idle": "2026-06-08T00:02:53.427660Z", + "shell.execute_reply": "2026-06-08T00:02:53.427163Z" } }, "outputs": [ @@ -497,7 +497,7 @@ }, { "cell_type": "markdown", - "id": "b674c60e", + "id": "6417a6c5", "metadata": {}, "source": [ "## 4. Fleet Assignment Model (FAM) - Nível Brasil\n", @@ -514,13 +514,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "7ced35c2", + "id": "37aa1929", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:34.560156Z", - "iopub.status.busy": "2026-06-07T23:57:34.560010Z", - "iopub.status.idle": "2026-06-07T23:57:34.585094Z", - "shell.execute_reply": "2026-06-07T23:57:34.584521Z" + "iopub.execute_input": "2026-06-08T00:02:53.430410Z", + "iopub.status.busy": "2026-06-08T00:02:53.430191Z", + "iopub.status.idle": "2026-06-08T00:02:53.461295Z", + "shell.execute_reply": "2026-06-08T00:02:53.460683Z" } }, "outputs": [ @@ -609,7 +609,7 @@ }, { "cell_type": "markdown", - "id": "561bc1a2", + "id": "bca983df", "metadata": {}, "source": [ "## 5. Modelo 2: Minimização de Aeronaves\n", @@ -623,13 +623,13 @@ { "cell_type": "code", "execution_count": 7, - "id": "77540075", + "id": "34085659", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:34.586622Z", - "iopub.status.busy": "2026-06-07T23:57:34.586482Z", - "iopub.status.idle": "2026-06-07T23:57:35.973784Z", - "shell.execute_reply": "2026-06-07T23:57:35.973311Z" + "iopub.execute_input": "2026-06-08T00:02:53.462799Z", + "iopub.status.busy": "2026-06-08T00:02:53.462638Z", + "iopub.status.idle": "2026-06-08T00:02:54.833751Z", + "shell.execute_reply": "2026-06-08T00:02:54.833286Z" } }, "outputs": [ @@ -651,17 +651,17 @@ "== QUADRO DE HORÁRIOS DIÁRIOS ==\n", "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração |\n", "|------------|----------|-----------|--------------------------|-----------|-----------|-----------|\n", - "| Aeronave 1 | SBSJ | SBBR | Passageiro | 00:00 | 02:09 | 129 min |\n", - "| Aeronave 1 | SBBR | SBGR | Passageiro | 02:09 | 04:19 | 130 min |\n", - "| Aeronave 1 | SBGR | SBBR | Passageiro | 04:19 | 06:29 | 130 min |\n", - "| Aeronave 1 | SBBR | SBAN | Passageiro | 06:29 | 06:47 | 18 min |\n", - "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 06:47 | 08:56 | 129 min |\n", - "| Aeronave 1 | SBSJ | SBGL | Passageiro | 08:56 | 09:38 | 42 min |\n", - "| Aeronave 1 | SBGL | SBSJ | Passageiro | 09:38 | 10:20 | 42 min |\n", - "| Aeronave 2 | SBBR | SBGL | Passageiro | 00:00 | 02:20 | 140 min |\n", - "| Aeronave 2 | SBGL | SBBR | Passageiro | 02:20 | 04:40 | 140 min |\n", - "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:52 | 52 min |\n", - "| Aeronave 3 | SBGL | SBGR | Passageiro | 00:52 | 01:44 | 52 min |\n" + "| Aeronave 1 | SBSJ | SBGL | Passageiro | 00:00 | 00:42 | 42 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 00:42 | 01:24 | 42 min |\n", + "| Aeronave 1 | SBSJ | SBBR | Passageiro | 01:24 | 03:33 | 129 min |\n", + "| Aeronave 1 | SBBR | SBGR | Passageiro | 03:33 | 05:43 | 130 min |\n", + "| Aeronave 1 | SBGR | SBGL | Passageiro | 05:43 | 06:35 | 52 min |\n", + "| Aeronave 1 | SBGL | SBGR | Passageiro | 06:35 | 07:27 | 52 min |\n", + "| Aeronave 1 | SBGR | SBBR | Passageiro | 07:27 | 09:37 | 130 min |\n", + "| Aeronave 1 | SBBR | SBGL | Passageiro | 09:37 | 11:57 | 140 min |\n", + "| Aeronave 1 | SBGL | SBBR | Passageiro | 11:57 | 14:17 | 140 min |\n", + "| Aeronave 1 | SBBR | SBAN | Passageiro | 14:17 | 14:35 | 18 min |\n", + "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 14:35 | 16:44 | 129 min |\n" ] } ], @@ -835,7 +835,7 @@ }, { "cell_type": "markdown", - "id": "c700c020", + "id": "b655f18a", "metadata": {}, "source": [ "## 6. Modelo 3: Minimização de Aeronaves com TAT (Turnaround Time)\n", @@ -848,13 +848,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "4b875ed9", + "id": "1ff4f6ff", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:35.975498Z", - "iopub.status.busy": "2026-06-07T23:57:35.975366Z", - "iopub.status.idle": "2026-06-07T23:57:35.993825Z", - "shell.execute_reply": "2026-06-07T23:57:35.993344Z" + "iopub.execute_input": "2026-06-08T00:02:54.835276Z", + "iopub.status.busy": "2026-06-08T00:02:54.835152Z", + "iopub.status.idle": "2026-06-08T00:02:54.854110Z", + "shell.execute_reply": "2026-06-08T00:02:54.853338Z" } }, "outputs": [ @@ -874,17 +874,17 @@ "== QUADRO DE HORÁRIOS DIÁRIOS (COM 40 MIN TAT) ==\n", "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração Voo |\n", "|------------|----------|-----------|--------------------------|-----------|-----------|---------------|\n", - "| Aeronave 1 | SBSJ | SBBR | Passageiro | 00:00 | 02:09 | 129 min |\n", - "| Aeronave 1 | SBBR | SBGR | Passageiro | 02:49 | 04:59 | 130 min |\n", - "| Aeronave 1 | SBGR | SBBR | Passageiro | 05:39 | 07:49 | 130 min |\n", - "| Aeronave 1 | SBBR | SBAN | Passageiro | 08:29 | 08:47 | 18 min |\n", - "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 09:27 | 11:36 | 129 min |\n", - "| Aeronave 1 | SBSJ | SBGL | Passageiro | 12:16 | 12:58 | 42 min |\n", - "| Aeronave 1 | SBGL | SBSJ | Passageiro | 13:38 | 14:20 | 42 min |\n", - "| Aeronave 2 | SBBR | SBGL | Passageiro | 00:00 | 02:20 | 140 min |\n", - "| Aeronave 2 | SBGL | SBBR | Passageiro | 03:00 | 05:20 | 140 min |\n", - "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:52 | 52 min |\n", - "| Aeronave 3 | SBGL | SBGR | Passageiro | 01:32 | 02:24 | 52 min |\n" + "| Aeronave 1 | SBSJ | SBGL | Passageiro | 00:00 | 00:42 | 42 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 01:22 | 02:04 | 42 min |\n", + "| Aeronave 1 | SBSJ | SBBR | Passageiro | 02:44 | 04:53 | 129 min |\n", + "| Aeronave 1 | SBBR | SBGR | Passageiro | 05:33 | 07:43 | 130 min |\n", + "| Aeronave 1 | SBGR | SBGL | Passageiro | 08:23 | 09:15 | 52 min |\n", + "| Aeronave 1 | SBGL | SBGR | Passageiro | 09:55 | 10:47 | 52 min |\n", + "| Aeronave 1 | SBGR | SBBR | Passageiro | 11:27 | 13:37 | 130 min |\n", + "| Aeronave 1 | SBBR | SBGL | Passageiro | 14:17 | 16:37 | 140 min |\n", + "| Aeronave 1 | SBGL | SBBR | Passageiro | 17:17 | 19:37 | 140 min |\n", + "| Aeronave 1 | SBBR | SBAN | Passageiro | 20:17 | 20:35 | 18 min |\n", + "| Aeronave 1 | SBAN | SBSJ | Vazio (Reposicionamento) | 21:15 | 23:24 | 129 min |\n" ] } ], @@ -1001,7 +1001,7 @@ }, { "cell_type": "markdown", - "id": "bcb47486", + "id": "1763af22", "metadata": {}, "source": [ "# Alocação de Frotas - Aeronaves C-99A\n", @@ -1011,13 +1011,13 @@ { "cell_type": "code", "execution_count": 9, - "id": "286bd66c", + "id": "1c4f2389", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:35.995282Z", - "iopub.status.busy": "2026-06-07T23:57:35.995152Z", - "iopub.status.idle": "2026-06-07T23:57:36.342199Z", - "shell.execute_reply": "2026-06-07T23:57:36.341657Z" + "iopub.execute_input": "2026-06-08T00:02:54.856067Z", + "iopub.status.busy": "2026-06-08T00:02:54.855898Z", + "iopub.status.idle": "2026-06-08T00:02:55.197782Z", + "shell.execute_reply": "2026-06-08T00:02:55.197166Z" } }, "outputs": [ @@ -1280,7 +1280,7 @@ }, { "cell_type": "markdown", - "id": "4475f157", + "id": "742232e8", "metadata": {}, "source": [ "## MODELO 4: Minimização de Distância (Custo)\n", @@ -1290,13 +1290,13 @@ { "cell_type": "code", "execution_count": 10, - "id": "32c7a014", + "id": "ffd85ca9", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:36.343895Z", - "iopub.status.busy": "2026-06-07T23:57:36.343763Z", - "iopub.status.idle": "2026-06-07T23:57:36.361322Z", - "shell.execute_reply": "2026-06-07T23:57:36.360699Z" + "iopub.execute_input": "2026-06-08T00:02:55.199228Z", + "iopub.status.busy": "2026-06-08T00:02:55.199102Z", + "iopub.status.idle": "2026-06-08T00:02:55.213916Z", + "shell.execute_reply": "2026-06-08T00:02:55.213276Z" } }, "outputs": [ @@ -1356,7 +1356,7 @@ }, { "cell_type": "markdown", - "id": "921176a9", + "id": "3f293c10", "metadata": {}, "source": [ "## MODELO 5: Minimização de Frota C-99A (S/ TAT)\n", @@ -1366,13 +1366,13 @@ { "cell_type": "code", "execution_count": 11, - "id": "0e7565cb", + "id": "948d033b", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:36.362787Z", - "iopub.status.busy": "2026-06-07T23:57:36.362646Z", - "iopub.status.idle": "2026-06-07T23:57:36.963443Z", - "shell.execute_reply": "2026-06-07T23:57:36.962899Z" + "iopub.execute_input": "2026-06-08T00:02:55.215350Z", + "iopub.status.busy": "2026-06-08T00:02:55.215231Z", + "iopub.status.idle": "2026-06-08T00:02:55.785030Z", + "shell.execute_reply": "2026-06-08T00:02:55.784476Z" } }, "outputs": [ @@ -1389,18 +1389,18 @@ "\n", "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração |\n", "|------------|----------|-----------|------------|-----------|-----------|-----------|\n", - "| Aeronave 1 | SBSJ | SBBR | Vazio | 00:00 | 01:34 | 94 min |\n", - "| Aeronave 1 | SBBR | SBSJ | Passageiro | 01:34 | 03:08 | 94 min |\n", - "| Aeronave 1 | SBSJ | SBGL | Vazio | 03:08 | 03:38 | 30 min |\n", - "| Aeronave 1 | SBGL | SBSJ | Passageiro | 03:38 | 04:08 | 30 min |\n", - "| Aeronave 2 | SBBR | SBGR | Passageiro | 00:00 | 01:35 | 95 min |\n", - "| Aeronave 2 | SBGR | SBBR | Passageiro | 01:35 | 03:10 | 95 min |\n", - "| Aeronave 2 | SBBR | SBAF | Passageiro | 03:10 | 04:52 | 102 min |\n", - "| Aeronave 2 | SBAF | SBBR | Passageiro | 04:52 | 06:34 | 102 min |\n", - "| Aeronave 2 | SBBR | SBGL | Passageiro | 06:34 | 08:16 | 102 min |\n", - "| Aeronave 2 | SBGL | SBBR | Passageiro | 08:16 | 09:58 | 102 min |\n", - "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:38 | 38 min |\n", - "| Aeronave 3 | SBGL | SBGR | Passageiro | 00:38 | 01:16 | 38 min |\n" + "| Aeronave 1 | SBSJ | SBGL | Vazio | 00:00 | 00:30 | 30 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 00:30 | 01:00 | 30 min |\n", + "| Aeronave 1 | SBSJ | SBBR | Vazio | 01:00 | 02:34 | 94 min |\n", + "| Aeronave 1 | SBBR | SBSJ | Passageiro | 02:34 | 04:08 | 94 min |\n", + "| Aeronave 2 | SBGR | SBGL | Passageiro | 00:00 | 00:38 | 38 min |\n", + "| Aeronave 2 | SBGL | SBGR | Passageiro | 00:38 | 01:16 | 38 min |\n", + "| Aeronave 2 | SBGR | SBBR | Passageiro | 01:16 | 02:51 | 95 min |\n", + "| Aeronave 2 | SBBR | SBGR | Passageiro | 02:51 | 04:26 | 95 min |\n", + "| Aeronave 3 | SBAF | SBBR | Passageiro | 00:00 | 01:42 | 102 min |\n", + "| Aeronave 3 | SBBR | SBAF | Passageiro | 01:42 | 03:24 | 102 min |\n", + "| Aeronave 4 | SBGL | SBBR | Passageiro | 00:00 | 01:42 | 102 min |\n", + "| Aeronave 4 | SBBR | SBGL | Passageiro | 01:42 | 03:24 | 102 min |\n" ] } ], @@ -1506,7 +1506,7 @@ }, { "cell_type": "markdown", - "id": "dee63bf7", + "id": "e218deab", "metadata": {}, "source": [ "## MODELO 6: Minimização de Frota C-99A (C/ 40 min TAT)\n", @@ -1516,13 +1516,13 @@ { "cell_type": "code", "execution_count": 12, - "id": "eefd3712", + "id": "c4c89733", "metadata": { "execution": { - "iopub.execute_input": "2026-06-07T23:57:36.965022Z", - "iopub.status.busy": "2026-06-07T23:57:36.964881Z", - "iopub.status.idle": "2026-06-07T23:57:36.980280Z", - "shell.execute_reply": "2026-06-07T23:57:36.979683Z" + "iopub.execute_input": "2026-06-08T00:02:55.786359Z", + "iopub.status.busy": "2026-06-08T00:02:55.786235Z", + "iopub.status.idle": "2026-06-08T00:02:55.800410Z", + "shell.execute_reply": "2026-06-08T00:02:55.799867Z" } }, "outputs": [ @@ -1538,18 +1538,18 @@ "\n", "| Aeronave | Origem | Destino | Tipo | Partida | Chegada | Duração |\n", "|------------|----------|-----------|------------|-----------|-----------|-----------|\n", - "| Aeronave 1 | SBSJ | SBBR | Vazio | 00:00 | 01:34 | 94 min |\n", - "| Aeronave 1 | SBBR | SBSJ | Passageiro | 02:14 | 03:48 | 94 min |\n", - "| Aeronave 1 | SBSJ | SBGL | Vazio | 04:28 | 04:58 | 30 min |\n", - "| Aeronave 1 | SBGL | SBSJ | Passageiro | 05:38 | 06:08 | 30 min |\n", - "| Aeronave 2 | SBBR | SBGR | Passageiro | 00:00 | 01:35 | 95 min |\n", - "| Aeronave 2 | SBGR | SBBR | Passageiro | 02:15 | 03:50 | 95 min |\n", - "| Aeronave 2 | SBBR | SBAF | Passageiro | 04:30 | 06:12 | 102 min |\n", - "| Aeronave 2 | SBAF | SBBR | Passageiro | 06:52 | 08:34 | 102 min |\n", - "| Aeronave 2 | SBBR | SBGL | Passageiro | 09:14 | 10:56 | 102 min |\n", - "| Aeronave 2 | SBGL | SBBR | Passageiro | 11:36 | 13:18 | 102 min |\n", - "| Aeronave 3 | SBGR | SBGL | Passageiro | 00:00 | 00:38 | 38 min |\n", - "| Aeronave 3 | SBGL | SBGR | Passageiro | 01:18 | 01:56 | 38 min |\n" + "| Aeronave 1 | SBSJ | SBGL | Vazio | 00:00 | 00:30 | 30 min |\n", + "| Aeronave 1 | SBGL | SBSJ | Passageiro | 01:10 | 01:40 | 30 min |\n", + "| Aeronave 1 | SBSJ | SBBR | Vazio | 02:20 | 03:54 | 94 min |\n", + "| Aeronave 1 | SBBR | SBSJ | Passageiro | 04:34 | 06:08 | 94 min |\n", + "| Aeronave 2 | SBGR | SBGL | Passageiro | 00:00 | 00:38 | 38 min |\n", + "| Aeronave 2 | SBGL | SBGR | Passageiro | 01:18 | 01:56 | 38 min |\n", + "| Aeronave 2 | SBGR | SBBR | Passageiro | 02:36 | 04:11 | 95 min |\n", + "| Aeronave 2 | SBBR | SBGR | Passageiro | 04:51 | 06:26 | 95 min |\n", + "| Aeronave 3 | SBAF | SBBR | Passageiro | 00:00 | 01:42 | 102 min |\n", + "| Aeronave 3 | SBBR | SBAF | Passageiro | 02:22 | 04:04 | 102 min |\n", + "| Aeronave 4 | SBGL | SBBR | Passageiro | 00:00 | 01:42 | 102 min |\n", + "| Aeronave 4 | SBBR | SBGL | Passageiro | 02:22 | 04:04 | 102 min |\n" ] } ], @@ -1628,6 +1628,556 @@ "\n", "print(tabulate(tabela_horarios_c99_6, headers=[\"Aeronave\", \"Origem\", \"Destino\", \"Tipo\", \"Partida\", \"Chegada\", \"Duração\"], tablefmt=\"github\"))\n" ] + }, + { + "cell_type": "markdown", + "id": "4845bd74", + "metadata": {}, + "source": [ + "# Alocação de Frotas - Mix (C-97 + C-99A)\n", + "Agora vamos analisar a demanda de forma unificada (soma dos passageiros transportados por C-97 e C-99A) e colocar as duas frotas para trabalhar em conjunto nos Modelos 7, 8 e 9.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5818c70c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-08T00:02:55.801763Z", + "iopub.status.busy": "2026-06-08T00:02:55.801641Z", + "iopub.status.idle": "2026-06-08T00:02:56.285567Z", + "shell.execute_reply": "2026-06-08T00:02:56.285011Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TrechoTotal_PAXDias_OperadosMedia_PAX_Dias_OperadosScore_Relevancia
264SBGL-SBBR1482.08317.855422123006.0
85SBBR-SBGL1399.08316.855422116117.0
321SBGR-SBBR483.04012.07500019320.0
88SBBR-SBGR428.03611.88888915408.0
280SBGL-SBGR374.03411.00000012716.0
65SBBR-SBAF341.01818.9444446138.0
110SBBR-SBSJ251.02211.4090915522.0
328SBGR-SBGL183.0306.1000005490.0
297SBGL-SBSJ182.0276.7407414914.0
504SBSJ-SBBR212.0239.2173914876.0
\n", + "
" + ], + "text/plain": [ + " Trecho Total_PAX Dias_Operados Media_PAX_Dias_Operados \\\n", + "264 SBGL-SBBR 1482.0 83 17.855422 \n", + "85 SBBR-SBGL 1399.0 83 16.855422 \n", + "321 SBGR-SBBR 483.0 40 12.075000 \n", + "88 SBBR-SBGR 428.0 36 11.888889 \n", + "280 SBGL-SBGR 374.0 34 11.000000 \n", + "65 SBBR-SBAF 341.0 18 18.944444 \n", + "110 SBBR-SBSJ 251.0 22 11.409091 \n", + "328 SBGR-SBGL 183.0 30 6.100000 \n", + "297 SBGL-SBSJ 182.0 27 6.740741 \n", + "504 SBSJ-SBBR 212.0 23 9.217391 \n", + "\n", + " Score_Relevancia \n", + "264 123006.0 \n", + "85 116117.0 \n", + "321 19320.0 \n", + "88 15408.0 \n", + "280 12716.0 \n", + "65 6138.0 \n", + "110 5522.0 \n", + "328 5490.0 \n", + "297 4914.0 \n", + "504 4876.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 1. Filtro e Limpeza Unificados (Mix)\n", + "df_mix = df[df['Modelo'].isin(['C-97', 'C-99A'])].copy()\n", + "df_mix = df_mix[df_mix['Localidade Decolagem'] != 0]\n", + "df_mix = df_mix[df_mix['Localidade Pouso'] != 0]\n", + "df_mix['Trecho'] = df_mix['Localidade Decolagem'] + '-' + df_mix['Localidade Pouso']\n", + "df_mix['PAX'] = pd.to_numeric(df_mix['PAX']).fillna(0)\n", + "df_mix['Dep TimeStamp'] = pd.to_datetime(df_mix['Data de Decolagem'] + ' ' + df_mix['Hora de Decolagem'], format='mixed', dayfirst=True)\n", + "df_mix['Data Apenas'] = df_mix['Dep TimeStamp'].dt.date\n", + "\n", + "# Demanda diária\n", + "demanda_diaria_mix = df_mix.groupby(['Trecho', 'Data Apenas'])['PAX'].sum().reset_index()\n", + "\n", + "todos_trechos_mix = demanda_diaria_mix['Trecho'].unique()\n", + "idx_mix = pd.MultiIndex.from_product([todos_trechos_mix, datas_2025], names=['Trecho', 'Data Apenas'])\n", + "demanda_diaria_completa_mix = pd.DataFrame(index=idx_mix).reset_index()\n", + "demanda_diaria_completa_mix = pd.merge(demanda_diaria_completa_mix, demanda_diaria_mix, on=['Trecho', 'Data Apenas'], how='left').fillna({'PAX': 0})\n", + "\n", + "estatisticas_trechos_mix = demanda_diaria_completa_mix.groupby('Trecho').agg(\n", + " Total_PAX=('PAX', 'sum'),\n", + " Dias_Operados=('PAX', lambda x: (x > 0).sum())\n", + ").reset_index()\n", + "\n", + "estatisticas_trechos_mix['Media_PAX_Dias_Operados'] = estatisticas_trechos_mix.apply(\n", + " lambda row: row['Total_PAX'] / row['Dias_Operados'] if row['Dias_Operados'] > 0 else 0, axis=1\n", + ")\n", + "estatisticas_trechos_mix['Score_Relevancia'] = estatisticas_trechos_mix['Total_PAX'] * estatisticas_trechos_mix['Dias_Operados']\n", + "estatisticas_trechos_mix = estatisticas_trechos_mix.sort_values(by='Score_Relevancia', ascending=False)\n", + "\n", + "NUM_TRECHOS_MIX = 10\n", + "top_trechos_mix = estatisticas_trechos_mix.head(NUM_TRECHOS_MIX)\n", + "\n", + "display(top_trechos_mix)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "sns.barplot(data=top_trechos_mix, x='Trecho', y='Score_Relevancia', hue='Trecho', palette='cubehelix', legend=False)\n", + "plt.title(f'Top {NUM_TRECHOS_MIX} Trechos MIX (C-97 + C-99A)')\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Rede Mix\n", + "G_mix = nx.DiGraph()\n", + "for _, row in top_trechos_mix.iterrows():\n", + " origem, destino = row['Trecho'].split('-')\n", + " G_mix.add_edge(origem, destino, weight=row['Score_Relevancia'])\n", + "pos_mix = nx.spring_layout(G_mix, k=2.5, iterations=100, seed=42)\n", + "plt.figure(figsize=(12, 8))\n", + "nx.draw_networkx_nodes(G_mix, pos_mix, node_size=1200, node_color='plum', edgecolors='black')\n", + "nx.draw_networkx_edges(G_mix, pos_mix, edgelist=G_mix.edges(), arrows=True, arrowstyle='-|>', arrowsize=25, edge_color='gray', width=2, node_size=1200, connectionstyle='arc3,rad=0.15')\n", + "nx.draw_networkx_labels(G_mix, pos_mix, font_size=12, font_weight='bold')\n", + "plt.title('Diagrama de Rede - Unificada', fontsize=14)\n", + "plt.axis('off')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "40dc1e44", + "metadata": {}, + "source": [ + "## MODELO 7: Minimização de Distância (Custo) com Mix de Frota\n", + "A malha será atendida pelas duas aeronaves. O modelo decide quem alocar para cobrir a **demanda em passageiros** de cada rota, visando minimizar o número total de voos * distância (simplificação de custo de combustível), e não exceder o tamanho da frota física de cada modelo.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e94d5e84", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-08T00:02:56.286990Z", + "iopub.status.busy": "2026-06-08T00:02:56.286869Z", + "iopub.status.idle": "2026-06-08T00:02:56.353873Z", + "shell.execute_reply": "2026-06-08T00:02:56.353236Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "== MODELO 7 (MIX C-97 e C-99A) ==\n", + "Status: Optimal\n", + "Distância Total da Operação Combinada: 7064.88 km\n", + "\n", + "Trecho: SBGL-SBBR | Demanda PAX: 18 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBBR-SBGL | Demanda PAX: 17 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBGR-SBBR | Demanda PAX: 12 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBBR-SBGR | Demanda PAX: 12 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBGL-SBGR | Demanda PAX: 11 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBBR-SBAF | Demanda PAX: 19 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBBR-SBSJ | Demanda PAX: 11 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBGR-SBGL | Demanda PAX: 6 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBGL-SBSJ | Demanda PAX: 7 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n", + "Trecho: SBSJ-SBBR | Demanda PAX: 9 | Oferecido: 30 | Alocados -> C-97: 1, C-99A: 0\n" + ] + } + ], + "source": [ + "# Preparação Modelo 7\n", + "rotas_lista_mix = top_trechos_mix['Trecho'].tolist()\n", + "\n", + "distancias_voo_mix = {}\n", + "for r in rotas_lista_mix:\n", + " origem, destino = r.split('-')\n", + " distancias_voo_mix[r] = calc_distancia(origem, destino)\n", + "\n", + "demanda_pax_mix = {}\n", + "for _, row in top_trechos_mix.iterrows():\n", + " demanda_pax_mix[row['Trecho']] = row['Media_PAX_Dias_Operados']\n", + "\n", + "prob7 = pulp.LpProblem(\"Fleet_Assignment_Mix_Brasil\", pulp.LpMinimize)\n", + "\n", + "X_97 = pulp.LpVariable.dicts(\"X_97\", rotas_lista_mix, lowBound=0, cat='Integer')\n", + "X_99 = pulp.LpVariable.dicts(\"X_99\", rotas_lista_mix, lowBound=0, cat='Integer')\n", + "\n", + "# Minimizar distância combinada\n", + "prob7 += pulp.lpSum([distancias_voo_mix[r] * (X_97[r] + X_99[r]) for r in rotas_lista_mix])\n", + "\n", + "# Restrição de demanda (Em PAX)\n", + "for r in rotas_lista_mix:\n", + " prob7 += (X_97[r] * CAPACIDADE_C97) + (X_99[r] * CAPACIDADE_C99) >= demanda_pax_mix[r]\n", + "\n", + "# Restrição de uso da frota global para o dia (simplificado a 1 perna por aeronave aqui)\n", + "prob7 += pulp.lpSum([X_97[r] for r in rotas_lista_mix]) <= total_aeronaves\n", + "prob7 += pulp.lpSum([X_99[r] for r in rotas_lista_mix]) <= total_aeronaves_c99\n", + "\n", + "prob7.solve(pulp.PULP_CBC_CMD(msg=False))\n", + "\n", + "print(\"== MODELO 7 (MIX C-97 e C-99A) ==\")\n", + "print(f\"Status: {pulp.LpStatus[prob7.status]}\")\n", + "print(f\"Distância Total da Operação Combinada: {pulp.value(prob7.objective):.2f} km\\n\")\n", + "\n", + "for r in rotas_lista_mix:\n", + " c97_alloc = int(X_97[r].varValue)\n", + " c99_alloc = int(X_99[r].varValue)\n", + " capacidade_gerada = (c97_alloc * CAPACIDADE_C97) + (c99_alloc * CAPACIDADE_C99)\n", + " print(f\"Trecho: {r:10} | Demanda PAX: {demanda_pax_mix[r]:.0f} | Oferecido: {capacidade_gerada} | Alocados -> C-97: {c97_alloc}, C-99A: {c99_alloc}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "c8c7d162", + "metadata": {}, + "source": [ + "## MODELO 8: Minimização Absoluta de Frota Mix (S/ TAT)\n", + "Diferente do Modelo 7, permitimos ciclos completos (vários voos por aeronave no dia) para minimizar a quantidade real de fuselagens exigidas para a operação. O modelo fará os reposicionamentos vazios necessários e alocará o voo ao tipo ideal.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8f74805e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-08T00:02:56.355316Z", + "iopub.status.busy": "2026-06-08T00:02:56.355184Z", + "iopub.status.idle": "2026-06-08T00:02:56.391012Z", + "shell.execute_reply": "2026-06-08T00:02:56.390340Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "== RESULTADO DO MODELO 8 (MIX SEM TAT) ==\n", + "Status: Optimal\n", + "Aeronaves C-97 necessárias: 0\n", + "Aeronaves C-99A necessárias: 1\n", + "Frota total mobilizada: 1 aeronaves\n", + "\n", + "Alocações para satisfazer a Demanda:\n", + " -> Trecho SBGL-SBBR : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBBR-SBGL : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBGR-SBBR : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBBR-SBGR : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBGL-SBGR : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBBR-SBAF : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBBR-SBSJ : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBGR-SBGL : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBGL-SBSJ : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n", + " -> Trecho SBSJ-SBBR : C-97 faz 0 voo(s) | C-99A faz 1 voo(s)\n" + ] + } + ], + "source": [ + "# Malha Aeroportuária\n", + "aeroportos_malha_mix = set()\n", + "for r in rotas_lista_mix:\n", + " o, d = r.split('-')\n", + " aeroportos_malha_mix.add(o)\n", + " aeroportos_malha_mix.add(d)\n", + "aeroportos_malha_mix = list(aeroportos_malha_mix)\n", + "\n", + "# Matrizes de tempo exclusivas de cada aeronave na malha mix\n", + "t_voo_97 = {}\n", + "t_voo_99 = {}\n", + "for o in aeroportos_malha_mix:\n", + " for d in aeroportos_malha_mix:\n", + " if o == d:\n", + " t_voo_97[(o, d)] = 0\n", + " t_voo_99[(o, d)] = 0\n", + " else:\n", + " dist = calc_distancia(o, d)\n", + " t_voo_97[(o, d)] = int(round((dist / vel_media_c97) * 60))\n", + " t_voo_99[(o, d)] = int(round((dist / vel_media_c99) * 60))\n", + "\n", + "prob8 = pulp.LpProblem(\"Minimizar_Frota_Mix\", pulp.LpMinimize)\n", + "\n", + "# D = Voos de Demanda (agora variável)\n", + "D_97 = pulp.LpVariable.dicts(\"D_97\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "D_99 = pulp.LpVariable.dicts(\"D_99\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "\n", + "# Y = Voos de Reposicionamento Vazios\n", + "Y_97 = pulp.LpVariable.dicts(\"Y_97\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "Y_99 = pulp.LpVariable.dicts(\"Y_99\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "\n", + "N_97 = pulp.LpVariable(\"N_97\", lowBound=0, cat='Integer')\n", + "N_99 = pulp.LpVariable(\"N_99\", lowBound=0, cat='Integer')\n", + "\n", + "# Objetivo: Minimizar a soma de aeronaves. \n", + "# Adicionamos pequenas penalidades para desempate:\n", + "# 1. Preferir tempo de voo menor nos reposicionamentos\n", + "# 2. C-99 é mais cara/maior, penalidade irrisória para preferir C-97 se ambas puderem (custo indireto)\n", + "penalidade_voo_97 = pulp.lpSum([(D_97[(i, j)] + Y_97[(i, j)]) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix])\n", + "penalidade_voo_99 = pulp.lpSum([(D_99[(i, j)] + Y_99[(i, j)]) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix])\n", + "prob8 += N_97 + N_99 + 0.001 * N_99 + 0.00001 * (penalidade_voo_97 + penalidade_voo_99)\n", + "\n", + "# Restrição de Demanda em PAX\n", + "# Todas as rotas que não são Top10 tem demanda = 0\n", + "for i in aeroportos_malha_mix:\n", + " for j in aeroportos_malha_mix:\n", + " r_name = f\"{i}-{j}\"\n", + " demanda = demanda_pax_mix.get(r_name, 0)\n", + " prob8 += (D_97[(i, j)] * CAPACIDADE_C97) + (D_99[(i, j)] * CAPACIDADE_C99) >= demanda\n", + "\n", + "# Restrições de Fluxo Circulares (separados por tipo)\n", + "for no in aeroportos_malha_mix:\n", + " # C-97\n", + " chegadas_97 = pulp.lpSum([D_97[(i, no)] + Y_97[(i, no)] for i in aeroportos_malha_mix])\n", + " partidas_97 = pulp.lpSum([D_97[(no, j)] + Y_97[(no, j)] for j in aeroportos_malha_mix])\n", + " prob8 += chegadas_97 == partidas_97\n", + " \n", + " # C-99\n", + " chegadas_99 = pulp.lpSum([D_99[(i, no)] + Y_99[(i, no)] for i in aeroportos_malha_mix])\n", + " partidas_99 = pulp.lpSum([D_99[(no, j)] + Y_99[(no, j)] for j in aeroportos_malha_mix])\n", + " prob8 += chegadas_99 == partidas_99\n", + "\n", + "# Restrições de tempo operacional diário\n", + "prob8 += pulp.lpSum([(D_97[(i, j)] + Y_97[(i, j)]) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_97 * 1440\n", + "prob8 += pulp.lpSum([(D_99[(i, j)] + Y_99[(i, j)]) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_99 * 1440\n", + "\n", + "# Restrições Físicas\n", + "prob8 += N_97 <= total_aeronaves\n", + "prob8 += N_99 <= total_aeronaves_c99\n", + "\n", + "prob8.solve(pulp.PULP_CBC_CMD(msg=False))\n", + "\n", + "print(\"\\n== RESULTADO DO MODELO 8 (MIX SEM TAT) ==\")\n", + "print(f\"Status: {pulp.LpStatus[prob8.status]}\")\n", + "print(f\"Aeronaves C-97 necessárias: {int(N_97.varValue)}\")\n", + "print(f\"Aeronaves C-99A necessárias: {int(N_99.varValue)}\")\n", + "print(f\"Frota total mobilizada: {int(N_97.varValue) + int(N_99.varValue)} aeronaves\\n\")\n", + "\n", + "print(\"Alocações para satisfazer a Demanda:\")\n", + "for r in rotas_lista_mix:\n", + " origem, destino = r.split('-')\n", + " d97_val = int(D_97[(origem, destino)].varValue)\n", + " d99_val = int(D_99[(origem, destino)].varValue)\n", + " print(f\" -> Trecho {r:10}: C-97 faz {d97_val} voo(s) | C-99A faz {d99_val} voo(s)\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "9fe80d00", + "metadata": {}, + "source": [ + "## MODELO 9: Minimização Absoluta de Frota Mix (C/ TAT 40 MIN)\n", + "Por fim, a versão que soma a demanda, usa as duas frotas simultaneamente, permite múltiplos voos por dia, gera reposicionamentos e pune **40 minutos** no chão (TAT) para cada perna voada por qualquer um dos aviões.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "97b2d5b6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-08T00:02:56.393978Z", + "iopub.status.busy": "2026-06-08T00:02:56.393575Z", + "iopub.status.idle": "2026-06-08T00:02:56.413806Z", + "shell.execute_reply": "2026-06-08T00:02:56.413342Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "== RESULTADO DO MODELO 9 (MIX COM 40 MIN TAT) ==\n", + "Status: Optimal\n", + "Aeronaves C-97 necessárias: 0\n", + "Aeronaves C-99A necessárias: 1\n", + "Frota total mobilizada: 1 aeronaves\n", + "\n", + "Tempo total de voo da frota combinada: 886 min (14.77 h)\n", + "Tempo de solo desperdiçado (TAT 40 min em 12 voos): 480 min (8.00 h)\n" + ] + } + ], + "source": [ + "# Modelo 9\n", + "prob9 = pulp.LpProblem(\"Minimizar_Frota_Mix_TAT\", pulp.LpMinimize)\n", + "\n", + "D_97_t = pulp.LpVariable.dicts(\"D_97t\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "D_99_t = pulp.LpVariable.dicts(\"D_99t\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "Y_97_t = pulp.LpVariable.dicts(\"Y_97t\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "Y_99_t = pulp.LpVariable.dicts(\"Y_99t\", [(o, d) for o in aeroportos_malha_mix for d in aeroportos_malha_mix], lowBound=0, cat='Integer')\n", + "\n", + "N_97_t = pulp.LpVariable(\"N_97t\", lowBound=0, cat='Integer')\n", + "N_99_t = pulp.LpVariable(\"N_99t\", lowBound=0, cat='Integer')\n", + "\n", + "TAT_min = 40\n", + "\n", + "penalidade_97 = pulp.lpSum([(D_97_t[(i, j)] + Y_97_t[(i, j)]) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix])\n", + "penalidade_99 = pulp.lpSum([(D_99_t[(i, j)] + Y_99_t[(i, j)]) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix])\n", + "prob9 += N_97_t + N_99_t + 0.001 * N_99_t + 0.00001 * (penalidade_97 + penalidade_99)\n", + "\n", + "for i in aeroportos_malha_mix:\n", + " for j in aeroportos_malha_mix:\n", + " r_name = f\"{i}-{j}\"\n", + " demanda = demanda_pax_mix.get(r_name, 0)\n", + " prob9 += (D_97_t[(i, j)] * CAPACIDADE_C97) + (D_99_t[(i, j)] * CAPACIDADE_C99) >= demanda\n", + "\n", + "for no in aeroportos_malha_mix:\n", + " prob9 += pulp.lpSum([D_97_t[(i, no)] + Y_97_t[(i, no)] for i in aeroportos_malha_mix]) == pulp.lpSum([D_97_t[(no, j)] + Y_97_t[(no, j)] for j in aeroportos_malha_mix])\n", + " prob9 += pulp.lpSum([D_99_t[(i, no)] + Y_99_t[(i, no)] for i in aeroportos_malha_mix]) == pulp.lpSum([D_99_t[(no, j)] + Y_99_t[(no, j)] for j in aeroportos_malha_mix])\n", + "\n", + "# TAT INCLUSO AQUI\n", + "prob9 += pulp.lpSum([(D_97_t[(i, j)] + Y_97_t[(i, j)]) * (t_voo_97[(i, j)] + TAT_min) for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_97_t * 1440\n", + "prob9 += pulp.lpSum([(D_99_t[(i, j)] + Y_99_t[(i, j)]) * (t_voo_99[(i, j)] + TAT_min) for i in aeroportos_malha_mix for j in aeroportos_malha_mix]) <= N_99_t * 1440\n", + "\n", + "prob9 += N_97_t <= total_aeronaves\n", + "prob9 += N_99_t <= total_aeronaves_c99\n", + "\n", + "prob9.solve(pulp.PULP_CBC_CMD(msg=False))\n", + "\n", + "print(\"\\n== RESULTADO DO MODELO 9 (MIX COM 40 MIN TAT) ==\")\n", + "print(f\"Status: {pulp.LpStatus[prob9.status]}\")\n", + "print(f\"Aeronaves C-97 necessárias: {int(N_97_t.varValue)}\")\n", + "print(f\"Aeronaves C-99A necessárias: {int(N_99_t.varValue)}\")\n", + "print(f\"Frota total mobilizada: {int(N_97_t.varValue) + int(N_99_t.varValue)} aeronaves\\n\")\n", + "\n", + "tempo_97_voo = sum([(int(D_97_t[(i, j)].varValue) + int(Y_97_t[(i, j)].varValue)) * t_voo_97[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix])\n", + "tempo_99_voo = sum([(int(D_99_t[(i, j)].varValue) + int(Y_99_t[(i, j)].varValue)) * t_voo_99[(i, j)] for i in aeroportos_malha_mix for j in aeroportos_malha_mix])\n", + "\n", + "total_voos = sum([(int(D_97_t[(i, j)].varValue) + int(Y_97_t[(i, j)].varValue) + int(D_99_t[(i, j)].varValue) + int(Y_99_t[(i, j)].varValue)) for i in aeroportos_malha_mix for j in aeroportos_malha_mix])\n", + "\n", + "print(f\"Tempo total de voo da frota combinada: {tempo_97_voo + tempo_99_voo} min ({(tempo_97_voo + tempo_99_voo)/60:.2f} h)\")\n", + "print(f\"Tempo de solo desperdiçado (TAT 40 min em {total_voos} voos): {total_voos * TAT_min} min ({(total_voos * TAT_min)/60:.2f} h)\")\n" + ] } ], "metadata": {