universidade federal do rio de janeiro · figura 13 - 4.2.1. tela de apresentação das entradas e...
TRANSCRIPT
Universidade Federal do Rio de Janeiro
Escola Politécnica
Engenharia Naval e Oceânica
Leonardo Almeida de Bem
Heurística baseada em programação linear para otimização
de velocidade de embarcações considerando o
deslocamento
Rio de Janeiro
2020
Universidade Federal do Rio de Janeiro
Escola Politécnica
Engenharia Naval e Oceânica
Leonardo Almeida de Bem
Heurística baseada em programação linear para otimização
de velocidade de embarcações considerando o
deslocamento
Projeto de Graduação apresentado ao
Curso de Engenharia Naval e Oceânica, da
Escola Politécnica, Universidade Federal do
Rio de Janeiro, como parte dos requisitos
necessários à obtenção do título de
Engenheira.
Orientadores: Raad Yahya Qassim
Rio de Janeiro
2020
Heurística baseada em programação linear para otimização de
velocidade de embarcações considerando o deslocamento
Leonardo Almeida de Bem
PROJETO DE GRADUAÇÃO SUBMETIDO AO CORPO DOCENTE DO CURSO DE
ENGENHARIA NAVAL E OCEÂNICA DA ESCOLA POLITÉCNICA DA
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO COMO PARTE DOS REQUISITOS
NECESSÁRIOS PARA A OBTENÇÃO DO GRAU DE ENGENHEIRO NAVAL E
OCEÂNICO.
Examinado por:
_______________________________________
Luiz Antônio Vaz Pinto, D.Sc
_______________________________________
Jean-David Job Emmanuel Marie Caprace, D.Sc
_______________________________________
Professor Raad Yahya Qassim - Orientador
Rio de Janeiro, RJ, Brasil
Março, 2020
iv
Almeida de Bem, Leonardo
Heurística baseada em programação linear para otimização de
velocidade de embarcações considerando o deslocamento / Leonardo
Almeida de Bem. – Rio de Janeiro: UFRJ/Escola Politécnica, 2020.
XVI, 150 p. 29,7 cm
Orientador: Raad Yahya Qassim
Projeto de Graduação – UFRJ/Escola Politécnica/ Engenharia
Naval e Oceânica, 2020.
Referências Bibliográficas: p. 47-48.
1. Otimização linear. 2. Deslocamento. 3. Consumo de
combustível. 4. Método Heurístico. 5. CPLEX 6.EXCEL I. Raad
Yahya Qassim. II. Universidade Federal do Rio de Janeiro, Escola
Politécnica, Curso de Engenharia Naval e Oceânica. III. Título.
v
Agradecimentos
Desejo agradecer em primeiro a minha família, aos meus pais que
sacrificaram de tudo para me dar educação e toda a base necessária para
estar onde estou e isso não tem preço. Ao meu irmão por sempre estar
comigo, por me ajudar e cuidar de mim. Aos meus tios Mauro e Mônica por
todo o carinho e cuidado, e por sempre estarem cuidando da minha família
nos momentos importantes. Aos meus tios "Toninho" e Marta e a seus filhos
por me tratarem como um filho no período que morei com eles. Por fim a todos
da família que são muitos que sempre confiaram em mim, em especial a
alguma primos: Ana Paula, Ricardo, Etienio, Dayane e Allan.
Em segundo, agradeço aos meus amigos de infância da "rua 5":
Nathan, Lucas, Gabriel, Maicon e outros. Local em que fui criado e pude
aprender a importância da educação e de possibilitarmos o acesso a ela, a
eles agradeço a amizade, confiança e todo o crescimento que obtive ao
crescer ao lado deles e participando de suas histórias e luta. Além disso,
agradeço a Lara, Thainá, Lucas Parussolo, Gabriel “Geday” e especialmente
a Caren Bueno que virou uma grande amiga e me ajudou e orientou tantas
vezes.
Aos amigos do Rio (Ana, Jebe, Thiago, Heitor, Zan, Léo, Renata e
família, Tainá e outros) que viraram de algum modo minha segunda família,
agradeço por toda ajuda, companheirismo e felicidade que me
proporcionaram nesse período de provas e trabalhos. Ao Edivaldo e a ao
Rogério e sua família, tia Priscila e tio Sidney, um agradecimento especial por
me ajudarem sempre que precisei e pelo carinho especial que tem comigo e
por terem me acolhido por tantos anos.
E por fim agradeço a todos professores e administrativos desde o
colégio "Asilo" até a UFRJ que me ajudaram a crescer, me formar e me
ensinaram tudo que podiam.
vi
Resumo do Projeto de Graduação apresentado à POLI/UFRJ como parte dos
requisitos necessários para a obtenção do grau de Engenheira.
Heurística baseada em programação linear para otimização de velocidade
de embarcações considerando o deslocamento.
Leonardo Almeida de Bem
Março/2020
Orientador: Raad Yahya Qassim
Curso: Engenharia Naval e Oceânica
A otimização da velocidade da embarcação é importante na logística
naval tanto para razões econômicas quanto ambientais, tendo em vista os
custos de combustível e a emissão de gases devido ao consumo de
combustível do navio, que depende da velocidade do navio. Neste trabalho,
uma contribuição científica original é realizada ao se desenvolver uma
heurística baseada em programação linear para se levar em conta a redução
do deslocamento da embarcação durante uma viagem, dado que o peso de
combustível na embarcação diminui devido ao consumo de combustível. A
Heurística proposta é implementada computacionalmente para o estudo de
um caso do mundo real, onde é mostrado que a performance do modelo é
excelente em termos de comparação de redução de combustível consumido
com o modelo em que o deslocamento é considerado constante durante a
viagem.
Palavras-Chave: Heurístico, Otimização, Programação linear, Deslocamento,
Consumo, Combustível, Redução.
vii
Abstract of Undergraduate Project presented to POLI/UFRJ as a partial
fulfillment of the requirements for the degree of Naval Engineer.
A Linear Programming Model for Ship speed optimization with Displacement
Leonardo Almeida de Bem
March/2020
Advisors: Raad Yahya Qassim.
Course: Naval Architecture and Marine Engineering
Ship speed optimization is important in naval logistics for economic and
environmental reasons, in view of the substantial costs and gas emissions due
ship fuel consumption which depends on ship speed. In this work, an original
scientific contribution is made by the development of a linear programming-
based heuristic to take into account ship displacement reduction during ship
voyage, as ship fuel tank capacity decreases due to ship fuel consumption.
The proposed heuristic is computationally implemented for a real-world case
study, whereby it performance is shown to be excellent in terms of ship fuel
consumption reduction in comparison with case when ship displacement is
assumed constant during ship voyage.
Keywords: Heuristic, Speed Optimization, Linear Programming,
Displacement, Fuel consuption, Reduction
viii
Lista de Ilustrações
Figura 1 – 1. Curva de emissão de gases x velocidade da embarcação Valemax [4] . 2
Figura 2 - 2.1. Ilustração do problema a ser resolvido ................................................ 6
Figura 3 – 3.1. Exemplo da aplicação do procedimento de dois passos para uma rota
onde se escolheu dividi-la em 4 trechos N=4 . .......................................................... 10
Figura 4 - 3.1.2. Curva de consumo de combustivel para um Valemax considerando a
embarcação carregada e somente em lastro, para mostrar o quanto varia a curva de
consumo perante a variação de deslocmaento. [4] ................................................... 14
Figura 5 - 3.2. Fluxograma do método heurístico proposto ....................................... 17
Figura 6 - 4.1. Janela de Dados sobre o IBM ILOG CPLEX Optimization Studio .... 22
Figura 7 - 4.1. Janela de dados sobre o VBA ............................................................ 22
Figura 8 - 4.1.2. Tela de entrada de Dados da modelagem em EXCEL ................... 25
Figura 9 - 4.1.2. Tela de Calculo interno do programa para divisão da rota em trechos
.................................................................................................................................. 25
Figura 10 - 4.1.2. Tela do Excel com os dados de entrada, dados do trecho e as
restições. ................................................................................................................... 27
Figura 11 - 4.1.2. Tela do Solver para se otimizar de forma linear (passo 1) mostrando
como foi utilizado o Solver nessa modelagem .......................................................... 28
Figura 12 - 4.2.1. Curva de consumo da embarcação Sea Fighter para o deslocamento
de 1400 ton utilizada por Brown [6] ........................................................................... 30
Figura 13 - 4.2.1. Tela de apresentação das entradas e resultados obtido por Brown
em seu estudo de caso [6] ........................................................................................ 31
Figura 14 - 4.3. Gráfico de resumo de resultados do consumo total estimado para a
embarcação Sea Fighter de acordo com a discretização N escolhida. ..................... 42
Figura 15 - 4.3. Gráfico de resumo de resultados do deslocamento final estimado da
embarcação Sea Fighter de acordo com a discretização N escolhida. ..................... 43
Figura 16 - 4.3. Gráfico de resumo do percentual de melhora na estimativa do
consumo final da embarcação Sea Fighter de acordo com a discretização N escolhida.
.................................................................................................................................. 44
Figura 17 - 5. Curva de Consumo de um VLCC para a embarcação com carga ou só
com Lastro. Fonte:[12] ............................................................................................. 46
ix
Lista de Tabelas
Tabela 1 – 1. Composição do custo total do navio [5] ................................................. 3
Tabela 2 - 4.1.1. Tabela de atualização do deslocamento e da taxa de consumo após
o trecho “n” ................................................................................................................ 24
Tabela 3 - 4.2.2.2. Tabela de correção após o trecho n=1, para rota dividida em 2
trechos ...................................................................................................................... 34
Tabela 4 - 4.2.3.1. Tela de entrada de dados para resolução do problema, rota sendo
considerada um único trecho (N=1). ......................................................................... 36
Tabela 5 - 4.2.3.1. Tela de resultados para cada trecho, na rota dividida em um único
trecho. ....................................................................................................................... 37
Tabela 6 - 4.2.3.1. Tela de resultado final da rota, rota dividida em um único trecho.
.................................................................................................................................. 37
Tabela 7 - 4.2.3.2. Tela de entrada de dados para resolução do problema, rota dividida
em 2 trechos (N=2). ................................................................................................... 38
Tabela 8 - 4.2.3.2. Tela de resultados para cada trecho, na rota dividida em 2 trechos
(N=2). ........................................................................................................................ 39
Tabela 9 - 4.2.3.2. Tela de resultado final da rota, rota dividida em 2 trechos (N=2).
.................................................................................................................................. 39
Tabela 10 - 4.2.3.1. Tela de resultado final da rota, rota dividida em um único trecho.
.................................................................................................................................. 40
Tabela 11 - 4.2.3.2. Tela de resultado final da rota, rota dividida em 2 trechos (N=2).
.................................................................................................................................. 40
Tabela 12 - 4.2.3.3. Tela de resultado final da rota, rota dividida em 3 trechos (N=3).
.................................................................................................................................. 40
Tabela 13 - 4.2.3.4. Tela de resultado final da rota, rota dividida em 5 trechos (N=5).
.................................................................................................................................. 40
Tabela 14 - 4.2.3.5. Tela de resultado final da rota, rota dividida em 7 trechos (N=7).
.................................................................................................................................. 41
Tabela 15 - 4.2.3.6. Tela de resultado final da rota, rota dividida em 10 trechos (N=10).
.................................................................................................................................. 41
Tabela 16 - 4.2.3.7. Tela de resultado final da rota, rota dividida em 15 trechos (N=15).
.................................................................................................................................. 41
x
Tabela 17 - 4.2.3.8. Tela de resultado final da rota, rota dividida em 20 trechos (N=20).
.................................................................................................................................. 41
Tabela 18 - 4.2.3.1. Tela de entrada de dados para resolução do problema, rota sendo
considerada um único trecho (N=1). ....................................................................... 116
Tabela 19 - 4.2.3.1. Tela de resultados para cada trecho, na rota dividida em um único
trecho. ..................................................................................................................... 117
Tabela 20 - 4.2.3.1. Tela de resultado final da rota, rota dividida em um único trecho.
................................................................................................................................ 117
Tabela 21 - 4.2.3.2. Tela de entrada de dados para resolução do problema, rota
dividida em 2 trechos (N=2). ................................................................................... 117
Tabela 22 - 4.2.3.2. Tela de resultados para cada trecho, na rota dividida em 2 trechos
(N=2). ...................................................................................................................... 118
Tabela 23 - 4.2.3.2. Tela de resultado final da rota, rota dividida em 2 trechos (N=2).
................................................................................................................................ 118
Tabela 24 - 4.2.3.3. Tela de entrada de dados para resolução do problema, rota
dividida em 3 trechos (N=3). ................................................................................... 119
Tabela 25 - 4.2.3.3. Tela de resultados para cada trecho, na rota dividida em 3 trechos
(N=3). ...................................................................................................................... 120
Tabela 26 - 4.2.3.3. Tela de resultado final da rota, rota dividida em 3 trechos (N=3).
................................................................................................................................ 120
Tabela 27 - 4.2.3.4. Tela de entrada de dados para resolução do problema, rota
dividida em 5 trechos (N=5). ................................................................................... 121
Tabela 28 - 4.2.3.4. Tela de resultados para cada trecho, na rota dividida em 5 trechos
(N=5). ...................................................................................................................... 121
Tabela 29 - 4.2.3.4. Tela de resultado final da rota, rota dividida em 5 trechos (N=5).
................................................................................................................................ 122
Tabela 30 - 4.2.3.5. Tela de entrada de dados para resolução do problema, rota
dividida em 7 trechos (N=7). ................................................................................... 122
Tabela 31 - 4.2.3.5. Tela de resultados para cada trecho, na rota dividida em 7 trechos
(N=7). ...................................................................................................................... 123
Tabela 32 - 4.2.3.5. Tela de resultado final da rota, rota dividida em 7 trechos (N=7).
................................................................................................................................ 124
xi
Tabela 33 - 4.2.3.6. Tela de entrada de dados para resolução do problema, rota
dividida em 10 trechos (N=10). ............................................................................... 124
Tabela 34 - 4.2.3.6. Tela de resultados para cada trecho, na rota dividida em 10
trechos (N=10). ....................................................................................................... 125
Tabela 35 - 4.2.3.6. Tela de resultado final da rota, rota dividida em 10 trechos (N=10).
................................................................................................................................ 126
Tabela 36 - 4.2.3.7. Tela de entrada de dados para resolução do problema, rota
dividida em 15 trechos (N=15). ............................................................................... 127
Tabela 37 - 4.2.3.7. Tela de resultados para cada trecho, na rota dividida em 15
trechos (N=15). ....................................................................................................... 128
Tabela 38 - 4.2.3.7. Tela de resultado final da rota, rota dividida em 15 trechos (N=15).
................................................................................................................................ 129
Tabela 39 - 4.2.3.8. Tela de entrada de dados para resolução do problema, rota
dividida em 20 trechos (N=20). ............................................................................... 129
Tabela 40 - 4.2.3.8. Tela de resultados para cada trecho, na rota dividida em 20
trechos (N=20). ....................................................................................................... 130
Tabela 41 - 4.2.3.8. Tela de resultado final da rota, rota dividida em 20 trechos (N=20).
................................................................................................................................ 133
xii
Sumário
1. Introdução .................................................................................................................................... 1
2. Definição do Problema .............................................................................................................. 5
2.1. Enunciado do Problema ................................................................................................. 6
2.2. Detalhes dos dados de entrada e dos dados de saída do problema ................. 6
2.3. Restrições do Problema ................................................................................................. 8
3. Método Heurístico ...................................................................................................................... 9
3.1. Procedimento de dois passos (“Two step procedure”) ......................................... 9
3.1.1. Modelo de Otimização ................................................................................................... 10
3.1.1.1. Modelo de otimização por programação linear [6] ................................................ 11
3.1.2. Atualização da taxa de consumo considerando a variação do Deslocamento
13
3.2. Modelagem do Problema.............................................................................................. 15
4. Implementação Computacional ............................................................................................ 21
4.1. Modelagem ....................................................................................................................... 22
4.1.1. Cplex .................................................................................................................................. 23
4.1.2. Excel .................................................................................................................................. 25
4.2. Estudo de Caso – Embarcação Seafighter .............................................................. 29
4.2.1. Caso Modelo – Artigo do Brown de 2007 [6]........................................................... 29
4.2.2. Resultados pela modelagem no Cplex ..................................................................... 31
4.2.2.1. Rota inteira sem considerar a variação de deslocamento: N=1 ........................ 32
4.2.2.2. Rota dividida em dois trechos: N=2 .......................................................................... 33
4.2.3. Resultados pela modelagem no Excel ..................................................................... 35
4.2.3.1. Rota inteira sem considerar o deslocamento: N=1 ............................................... 36
4.2.3.2. Rota dividida em dois trechos: N=2 .......................................................................... 38
4.3. Análise dos Resultados ................................................................................................ 41
5. Conclusão .................................................................................................................................. 45
Referências ........................................................................................................................................ 47
ANEXO 1 ............................................................................................................................................. 49
ANEXO 2 ........................................................................................................................................... 116
ANEXO 3 ........................................................................................................................................... 134
1
1. Introdução
A redução do consumo de óleo diesel por embarcações navais influencia
diretamente no custo de viagem e na emissão de gases poluentes para a atmosfera,
dois fatores muito importantes que podem fazer um navio ganhar ou não um contrato.
Por isso a otimização do consumo de combustível de uma embarcação em sua viagem
é tão importante, ainda mais ao se levar em consideração a variação da curva de
consumo durante a viagem em função da variação do deslocamento, dado que mostra
resultados mais próximos da realidade e assim pode-se mostrar a clientes e
investidores benefícios da utilização da embarcação requerida uma vez que ela utiliza-
se de um programa de otimização de consumo de combustível.
A preocupação do ser humano com o meio ambiente vem crescendo e para
isso busca-se meios de reduzir ao máximo a poluição gerada pela queima de
combustíveis fósseis, algumas linhas de pesquisa buscam a substituição total desses
combustíveis, porém essa substituição total ainda demorará alguns anos. Como
medida mais imediata, os órgãos mundiais adotaram algumas regulamentações com
o objetivo de impor as empresas a redução de gases poluentes, MEPC.203 (62) [1].
Para isso, está se aperfeiçoando um plano de gestão de eficiência energética,
conhecido como SEEMP (Ship Energy Efficiency Management Plan) [2], que tem
como objetivo criar planos ou métodos eficientes de processos que resultem na
redução do consumo de combustíveis fósseis. Por exemplo o plano periódico de
limpeza do casco (retirada das cracas) e pintura com tinta anti-incrustrantes que
retardam o surgimento de cracas, isso gera uma melhora de performance do casco
durante a viagem, devido a menor resistência ao avanço gerada e desta forma é
possível reduzir o consumo [3]; Como pode-se verificar na figura 01, a emissão de
gases aumenta com o aumento da velocidade, pois segue o aumento do consumo de
combustível e ainda é possível verificar a diferença entre a emissão quando a
embarcação está carregada (maior deslocamento) e quando está somente com lastro
(menor deslocamento), evidenciando a importância desse estudo ao considerar no
modelo de otimização a influência da variação do deslocamento na curva de consumo
da embarcação.
2
Figura 1 – 1. Curva de emissão de gases x velocidade da embarcação Valemax [4]
Ao se reduzir o consumo de combustível além da diminuição da emissão de
gases poluentes, há uma economia nos custos da embarcação. Mesmo que para
embarcações afretadas esse custo não seja arcado pelo armador do navio, o consumo
de combustível é um dos fatores de desempate quando essas embarcações
participam de alguma licitação. O consumo é muito importante, pois segundo a Drewry
Shipping Consultant [5] os custos de uma embarcação podem ser divididos em três
tipos de custo: Capital, Operacional e de Viagem.
Sendo o custo de viagem correspondente entre 22% a 35% do custo total de
uma embarcação, dado que o custo de combustível corresponde em até 70% do custo
de viagem, como pode ser visto na Tabela 1-1 [5] Um valor considerável quando se
assume o valor total de uma embarcação e por isso uma redução no consumo se torna
tão importante.
Em alguns contratos de afretamento, muito utilizados para embarcações de
apoio offshore, o custo de combustível viagem é do afretador e por isso ao contratar
uma embarcação é sempre levado em conta o valor da diária cobrado mais o consumo
de combustível, desta forma é sempre desejado uma embarcação com o menor
consumo de combustível possível e por isso é de suma importância fornecer sistemas
de gerenciamento de eficiência das embarcações, principalmente um que minimize o
custo de viagem.
3
Tabela 1 – 1. Composição do custo total do navio [5]
Visto os dois contextos apresentados de redução de custos e de emissão de
poluentes o objetivo do presente projeto é desenvolver um método que minimize o
consumo de combustível ao otimizar as velocidades de uma embarcação durante uma
certa viagem considerando que ao transcorrer da viagem a embarcação varie seu
deslocamento, isso altera a sua curva de consumo de combustível. Ao se considerar
a variação de deslocamento durante a viagem é possível refinar a otimização já
realizada por Brown, 2007 [6], que obtém um conjunto de tempo em que a e
embarcação deve ficar em cada velocidade, resultando então num consumo menor.
No trabalho apresentado neste projeto final, é fornecido uma contribuição
científica original ao se apresentar um método de dois procedimentos onde permite-
se o refino da otimização apresentada por Brown [6], em função que neste estudo
será levado em consideração a variação na curva de consumo ao longo da rota em
função da variação do deslocamento da embarcação, devido a diminuição do peso de
combustível na embarcação dado o consumo de combustível, resultando assim em
um modelo mais real, sendo menos conservador que o modelo de Brown [6]. Isso é
feito pelo desenvolvimento de uma heurística baseada em programação linear, na
4
qual a distância entre os portos de origem e destino é discretizada em vários
segmentos. A heurística proposta é implementada computacionalmente para
aplicação em um estudo de caso do mundo real, e o desempenho da heurística é
assim avaliado
Para o entendimento do modelo desenvolvido será apresentado a definição do
problema, onde busca-se descrever o problema em questão e então evidenciar o
exato enunciado do problema a ser modelado e então resolvido, quais são os dados
conhecidos e por isso serão entradas do modelo, quais são os dados variáveis e por
fim qual deverá ser a saída do modelo.
A seguir será descrito o método Heurístico do projeto, apresentando o
procedimento de dois passos (two step procedure) utilizado para levar em
consideração a variação do deslocamento, além de mostrar a otimização
desenvolvida pelo departamento de pesquisa da Escola de Pós-graduação Naval
americana [6], será apresentado a teoria por trás da variação do consumo ao longo
da rota e como será recalculado o consumo ao final de cada passo. Por fim será
apresentado o modelo de otimização que solucione o problema definido. Ainda, será
apresentada as notações utilizadas, as equações que modelam o problema.
Conhecendo o modelo teórico, mostra-se a aplicação computacional, com isso
deve-se verificar a notação utilizada e a modelagem para cada programa (CPLEX e
Excel) e sua aplicação em um estudo de caso real que já foi estudado por Brown [6]
para que dessa forma seja possível comparar os resultados obtidos nesse estudo aqui
apresentado com o resultado apresentado por Brown [6], em resumo será possível
verificar quão menor será o consumo total de combustível ao longo da rota calculado
por este modelo perante o de Brown [6], vendo assim a influência em considerar a
variação de deslocamento durante a viagem. E ainda, será possível analisar a
influência no resultado de acordo com a discretização utilizada no procedimento de
dois passos “two step procedure”. Com os resultados e a comparação com o modelo
de Brown [6] será apresentada as conclusões do autor.
5
2. Definição do Problema
O problema em questão é uma evolução do problema de otimização de
velocidade de navios, onde busca-se minimizar o consumo de combustível durante
uma viagem entre dois portos, para isso determina-se um conjunto de velocidades e
o respectivo tempo em cada velocidade durante a viagem. Contudo, neste problema,
leva-se em conta a redução do deslocamento do navio durante a viagem. Redução
essa que se dá de forma simplificada pelo consumo do próprio combustível. Essa
mudança de deslocamento influencia a curva de consumo da embarcação, desta
forma quando não se considera a variação de deslocamento está se superestimando
o problema.
É importante entender que a curva de consumo de uma embarcação depende
de várias características da embarcação como o estado do casco, a idade da
embarcação, a velocidade e o deslocamento dela, sendo que este é influenciado pelos
consumíveis a bordo, pela carga transportada e pelo lastro. Ainda há a influência do
tempo, onde um mar calmo ou muito agitado afeta a curva de consumo, o mesmo
pode-se dizer das correntes marítimas. Psaraftis e Kontovas (2013, 2014) [12], [13]
fizeram um extenso estudo da função de consumo de combustível na velocidade do
navio. Eles apontaram que é uma função complexa, que depende de vários fatores,
como a carga útil do navio e as condições climáticas, como as ondas do vento e do
mar. Bialystocki e Konovessis (2016) [14] adotaram uma abordagem operacional, com
base em uma análise estatística de dados de um grande número de viagens de navios,
e desenvolveram um algoritmo no qual são levados em consideração o calado,
deslocamento do navio, condições climáticas e aspereza do casco e da hélice do
navio.
Neste problema considera-se, por necessidade de simplificar o problema, que
durante a viagem em questão os fatores externos (estado de mar e correntes) e as
características da embarcação, como estado do casco e idade, não irão alterar o
consumo da embarcação. De forma que o consumo de combustível será função da
velocidade em questão e do deslocamento da embarcação, de forma que dado a taxa
de consumo de combustível no início da viagem, ao percorrer o trajeto isso causará
uma diminuição do deslocamento da embarcação, ou seja, com o passar da viagem
a embarcação ficará mais leve, desta forma, devido ao menor deslocamento,
6
consumirá menos combustível, variação que ocorrerá durante toda a viagem e que
será levada em conta na resolução deste problema.
2.1. Enunciado do Problema
Busca-se neste estudo resolver o seguinte problema: dada uma embarcação
conhecida (conhece-se seu deslocamento inicial, sua respectiva taxa de consumo
para cada velocidade, o volume de combustível total e o volume de combustível que
deve ser armazenado por segurança e o conjunto de velocidades que a embarcação
consegue performar) e a rota a ser percorrida (conhecido a distância a ser percorrida
e o tempo máximo para se realizar o trajeto), deseja-se definir o tempo em que a
embarcação deve ficar em cada velocidade de forma a se minimizar o consumo de
combustível considerando a variação de deslocamento durante o trajeto, sendo que
deve-se respeitar o tempo limite que a embarcação possui para realizar a rota e não
se pode gastar mais combustível do que a embarcação possuir.
Figura 2 - 2.1. Ilustração do problema a ser resolvido
2.2. Detalhes dos dados de entrada e dos dados de saída do
problema
Desta forma as informações a seguir são entradas conhecidas do projeto:
A. Dados da embarcação: da embarcação objeto do problema deve-se
conhecer o Deslocamento inicial de partida (ex: ∇0), o conjunto de
Velocidades que a embarcação pode desempenhar (ex: [𝑣1; 𝑣2; … ; 𝑣𝑠] )
e a taxa de consumo para cada velocidade (ex: [𝑇𝑥𝑣1; 𝑇𝑥𝑣2
; … ; 𝑇𝑥𝑣𝑠]).
7
Também se conhece o volume máximo de combustível disponível (Ex:
Vmax) e o volume reserva (ex: Vreserva) que deve ser mantido por
segurança.
Vale ressaltar que a curva de consumo de combustível é dada em
função do deslocamento da embarcação, desta forma é necessário
saber o deslocamento inicial da embarcação na partida. Uma
simplificação usada nesse problema é não considerar a variação da
curva de consumo dado as condições de mar e vento, tipo de
combustível e outros fatores.
B. Dados da rota: não é necessário conhecer o local de partida (porto de
partida) e o local de destino (porto de destino), porém é necessário saber
a distância total a ser percorrida (esta é mais uma simplificação do
problema ao não se levar em consideração o local da rota, pois há locais
que afetam diretamente na navegação e no tempo como por exemplo
uma rota que passe pelo canal do Panamá). A data de saída do porto
inicial e a data limite para se chegar ao porto de destino deve ser
conhecida. Desta forma, o percurso é conhecido e assim sabe-se a
distância total a ser percorrida pela embarcação e o tempo máximo de
trajeto. Neste problema as correntes marítimas que podem contribuir ou
prejudicar no desempenho da embarcação serão desconsideradas,
sendo assim nesse problema necessita-se apenas saber a distância a
ser percorrida e o tempo máximo permitido.
Dadas as entradas do problema, ao se aplicar a modelagem
apresentada ao longo deste projeto será obtida as seguintes saídas:
C. Conjunto de tempo em que a embarcação deverá se manter para cada
velocidade durante cada trajeto (ex: [ 𝑇𝑣1; 𝑇𝑣2
; … ; 𝑇𝑣𝑠] ). Desta forma será
definido as velocidades que a embarcação deve desempenhar em cada
trecho e por quanto tempo, possuindo esse tempo será possível obter
também o tempo total gasto em cada trecho e ao longo de toda a viagem,
tempo esse que deverá ser menor que o tempo máximo informado com
entrada.
8
D. O volume de combustível consumido ao longo de cada trecho em por
isso, será calculado também o volume total de combustível a ser
utilizado em todo trajeto, volume esse que deverá respeitar o volume
limite informado nos dados de entrada.
2.3. Restrições do Problema
Como mencionado o problema a ser resolvido pela heurística proposta é uma
simplificação e por isso, vale a pena se ressaltar e identificar todas as restrições
impostas ao modelo para que ele possa ser aplicado de forma correta e que evite
propagação de erros no futuro. O modelo em questão não leva em consideração
os demais fatores, além do deslocamento, que influenciam na curva de consumo
ou velocidade da embarcação, desta forma as variações ambientais (vento, onda,
corrente) não são consideradas, nem os tipos de combustível, idade da
embarcação e outras características indicadas em [12] e [13]. Além disso, o
problema atual não considera carga e descarga, reabastecimento, intervalo de
chegada, contudo a implementação desse problema é simples e pode ser tratada
nos projetos futuros. Além disso, a rota é considerada fixa, não podendo ser
mudada. Qualquer alteração na rota, no tempo de percurso e nas características
da curva de consumo inicial deve-se rodar novamente o modelo com a atualização
das informações.
9
3. Método Heurístico
3.1. Procedimento de dois passos (“Two step procedure”)
Uma embarcação durante uma viagem vária constantemente seu
deslocamento, desta forma mudando a cada segundo sua curva de consumo.
Contudo, em pequenos trechos essa variação do deslocamento de uma embarcação
é quase imperceptível devido à grande parcela de peso que não vária durante a
viagem, devido aos pesos fixos durante a viagem, como peso leve (casco e
máquinas), peso da carga e outros.
Visto isso, para conseguir manter o problema linear foi adotado o procedimento
de dois passos, traduzido do termo em inglês conhecido como “Two step procedure”,
onde divide-se o problema em duas partes e resolveremos cada parte de uma forma.
No problema a ser resolvido deseja-se otimizar o consumo de combustível
considerando a variação do deslocamento durante a viagem. Para isso, então divide-
se o problema em duas partes:
i. Problema Linear: uma parte em que distância percorrida é pequena suficiente
para considerar-se que a variação do deslocamento não altera
significantemente a curva de consumo e devido a isso ela será considerada
constante durante esse trecho. Dado que nesse trecho a curva de consumo
não se altera então pode-se para este trecho otimizar o consumo de
combustível utilizando uma modelagem linear para solucionar o problema.
Neste projeto, decidiu-se utilizar o modelo de programação linear apresentado
pelo instituto americano e escrito por Brown em 2007 [6], contudo é possível
utilizar qualquer modelo de otimização desejado para resolver esse problema
em questão. Feita a otimização de consumo para a primeira parte, então
termina-se o primeiro passo e inicia-se o segundo.
ii. Atualização do deslocamento e taxa de consumo: A segunda parte é o final
do trecho analisado, onde será calculado o deslocamento atual da embarcação
e assim recalculado a taxa de consumo da embarcação devido a variação do
deslocamento. Neste ponto atualiza-se o deslocamento e a taxa de consumo
da embarcação, dado o consumo de combustível utilizado na primeira parte.
10
Para atualizar essas informações pode-se utilizar a relação matemática deseja
pelo usuário do método, neste projeto será utilizado as relações apresentadas
por Mersin em 2017 [7].
Atualizada as informações, pode-se repetir o procedimento “n” vezes até a
embarcação percorrer todo o caminho entre os portos. Dado que o trecho analisado é
um trecho pequeno suficiente de acordo com o desejo do usuário de se minimizar o
erro. Assim divide-se a rota entre os portos em trechos de preferência iguais e repete-
se o procedimento para cada trecho, assim se foi escolhido pelo usuário 4 trechos
tem-se N=4, onde “n” representa a discretização da rota, “n” sendo cada trecho. E
assim tem que o trecho analisado será a distância da rota dividido por “N”, neste caso
4. E devido a isso tem-se quatro trechos e por isso aplica-se esse procedimento 4
vezes, como pode ser visto na figura 3.
Figura 3 – 3.1. Exemplo da aplicação do procedimento de dois passos para uma rota onde se escolheu dividi-la em 4 trechos N=4 .
3.1.1. Modelo de Otimização
O método de solução adotado no primeiro passo do método Heurístico
apresentado pode ser qualquer método de otimização que o usuário do método
desejar. Como durante o curso de engenharia naval na disciplina “Logística e
transporte aquaviário – EEN586” foi apresentado o método de otimização utilizando
programação linear desenvolvido por Brown [6], devido a isso decidiu-se utilizar esse
método como método de otimização da parte do primeiro passo do procedimento,
como explicado acima. Abaixo será explicado um pouco sobre o método de otimização
linear escolhido e sua modelagem que será aplicado para otimizar o consumo em
cada trecho.
11
3.1.1.1. Modelo de otimização por programação linear [6]
Para evitar um problema não linear Brown decidiu definir um conjunto de
velocidades já conhecida e decidiu variar o tempo que a embarcação ficaria
em cada velocidade ao longo do trajeto, desta forma ao invés de se várias
a velocidade para se achar o menor consumo de combustível será variado
o tempo de cada velocidade. De forma a se respeitar as restrições de
distância a ser percorrida e tempo durante a viagem.
O problema a ser resolvido pela Marinha americana é o mesmo
apresentado no item 2., sem levar em consideração a variação de
deslocamento da embarcação durante a viagem, desta forma a curva de
consumo conhecida na partida da embarcação não será alterada durante o
trajeto.
A notação utilizada por eles e que será utilizada ao longo desse projeto
é:
Index:
𝑣 ∈ 𝑉 → 𝑣 𝑟𝑒𝑝𝑟𝑒𝑠𝑒𝑛𝑡𝑎 𝑜 𝑛𝑎𝑣𝑖𝑜 𝑎𝑛𝑎𝑙𝑖𝑠𝑎𝑑𝑜 𝑒 𝑉 𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜 𝑑𝑒 𝑛𝑎𝑣𝑖𝑜𝑠;
𝑠 ∈ 𝑆 → 𝑠 é 𝑜 𝑖𝑛𝑑𝑒𝑥 𝑑𝑎 𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 𝑒 𝑆 𝑜 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒𝑠 𝑐𝑜𝑛𝑠𝑖𝑑𝑒𝑟𝑎𝑑𝑎;
Por exemplo se o conjunto de velocidade for 4, 5 e 6. S vale 3, pois há
três velocidades e se “s” for 1, corresponderá a velocidade 4 e assim por
diante, “s”=2 corresponde a velocidade 5 e “s”=3 corresponde a velocidade
6.
Informações conhecidas e suas unidades:
𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑒 distância a ser percorrida entre os portos em milhas náuticas;
𝑠𝑝𝑒𝑒𝑑𝑠 velocidade da embarcação em knots (milhas náuticas por hora) e
seu index 𝑠;
𝑓𝑟𝑎𝑡𝑒𝑣,𝑠 taxa de consumo de combustível para a embarcação 𝑣 e para a
velocidade 𝑠 dado em galões por hora;
𝑓𝑢𝑒𝑙𝑣 capacidade de armazenamento de combustível da embarcação 𝑣,
dado em Galões;
12
𝑟𝑒𝑠𝑒𝑟𝑣𝑒_𝑓𝑢𝑒𝑙𝑣 volume de combustível a ser reservado por quesitos de
segurança, dado em Galões;
ℎ𝑜𝑢𝑟𝑠 máximo de tempo em que a embarcação tem que completar a
viagem, dado em horas;
Variáveis do problema:
𝐻𝑂𝑈𝑅𝑆𝑆 tempo gasto em cada velocidade 𝑠, dado em horas;
𝐹𝑈𝐸𝐿𝑣 total de combustível consumido durante a viagem;
Para resolver o problema dessa forma Brown, Kline, Rosenthal and
Washburn modelaram o problema com a seguinte programação linear:
(𝐸0)𝑀𝐼𝑁 𝐹𝑈𝐸𝐿𝑣
(𝐸1) ∑ 𝑠𝑝𝑒𝑒𝑑𝑠𝐻𝑂𝑈𝑅𝑆𝑆 ≥ 𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑒, 𝑠∈𝑆
(𝐸2) ∑ 𝐻𝑂𝑈𝑅𝑆𝑠 ≤ ℎ𝑜𝑢𝑟𝑠,𝑠∈𝑆
(𝐸3)𝐹𝑈𝐸𝐿𝑣 ≥ ∑ 𝑓𝑟𝑎𝑡𝑒𝑣,𝑠𝐻𝑂𝑈𝑅𝑆𝑠,𝑠∈𝑆
(𝐸4)𝐹𝑈𝐸𝐿𝑣 ≤ 𝑓𝑢𝑒𝑙𝑣 − 𝑟𝑒𝑠𝑒𝑟𝑣𝑒_𝑓𝑢𝑒𝑙𝑣,
(𝐸5)𝐻𝑂𝑈𝑅𝑆𝑠 ≥ 0 ∀ 𝑠 ∈ 𝑆.
Onde 𝐸𝑂 é a equação objetivo, a qual o objetivo é ser minimizada. A
equação 𝐸1 garante que a distância percorrida pela embarcação seja maior
ou igual a distância entre os portos. A equação 𝐸2 garante que o tempo de
viagem seja menor ou igual ao tempo máximo imposto. A equação 𝐸3
calcula o total de combustível consumido dado o conjunto de tempo em
cada velocidade escolhido. A equação 𝐸4 garante que não seja consumido
mais combustível que o permitido. E a equação 𝐸5 é uma restrição para
evitar que o programa encontre a solução trivial do problema que é tudo
zero.
Desta forma é possível chegar a um conjunto de tempo em que a
embarcação deve permanecer em dadas velocidades para assim consumir
o mínimo de combustível, de forma que o problema é resolvido utilizando
programação linear.
13
Vale ressaltar que a marinha americana utiliza-se do Solver do Excel
para resolver o problema de maneira similar à que será apresentada no
decorrer do projeto, criando uma tela amigável em que é necessário apena
Imputar a distância requerida, o tempo desejado, o volume de combustível
disponível e a curva de consumo da embarcação, que ao clicar em Solver
o programa apresenta os resultados.
3.1.2. Atualização da taxa de consumo considerando a variação do
Deslocamento
O segundo passo do procedimento “two step procedure” consiste na
atualização da taxa de consumo e da variação do deslocamento e para isso
optou-se por utilizar as relação matemática que o artigo de Mersin [7] que utiliza
para fazer comparação com a sua equação de variação do deslocamento com
o tempo, pois o artigo demonstra que apesar de simples a equação escolhida
é boa o suficiente. Desta forma a atualização do deslocamento será dada por:
(𝑄0) ∇𝑛= ∇𝑛−1 − 𝐹𝑈𝐸𝐿𝑛−1. 𝜌
Dado que o deslocamento da embarcação é dado pelo peso total da
embarcação, e durante o trecho percorrido a embarcação mantem todos os
grandes pesos como peso do casco, peso de máquina e de carga, perdendo
apenas o peso do combustível consumido, desta forma o deslocamento após
um trecho será dado pelo deslocamento do trecho anterior (Δ𝑛−1) subtraído do
peso do combustível consumido no trecho n (𝐹𝑈𝐸𝐿𝑛−1. 𝜌), sendo o peso o
volume de combustível calculado pela multiplicação do volume de combustível
consumido no trecho n (𝐹𝑈𝐸𝐿𝑛−1) pela densidade do combustível utilizado (𝜌).
Atualizado o deslocamento, inicia-se a atualização da taxa de consumo.
De forma muito conhecida entre os estudantes a relação de consumo e
velocidade é dada como uma equação cúbica, apresentada por Ronen em 1982
[8], sendo modelada como:
(𝑄01) 𝐹(𝑣) = 𝑐. 𝑣3
Sendo “c” uma constante positiva, que indica a inclinação da curva.
14
Figura 4 - 3.1.2. Curva de consumo de combustivel para um Valemax considerando a embarcação carregada e somente em lastro, para mostrar o quanto varia a curva de consumo perante a variação de deslocmaento. [4]
Na figura 4 é possível verificar a variação na curva de consumo de uma
embarcação devido a variação do deslocamento, onde a curva preta com
losangos apresenta o maior consumo devido ao maior deslocamento, já a curva
cinza com quadrados apresenta um consumo menor para a mesma velocidade
devido a seu menor deslocamento.
Alguns modelos de equações para cálculo do consumo de combustível
de uma embarcação não levam em consideração o deslocamento da
embarcação, o que para pequenas distâncias pode não fazer grande diferença,
porém ao se navegar e consumir combustível, você altera o deslocamento da
embarcação e essa alteração irá alterar a resistência ao avanço dado que você
irá mudar a área molhada. Isso influencia no consumo de combustível e o que
Kadir Mersin desenvolveu foi um método de calcular a variação do
deslocamento do navio no tempo dado seu consumo de combustível.
Para isso ele utiliza da equação apresentada por Barras em 2004 [9],
onde ele relaciona o consumo da embarcação com seu deslocamento:
(𝑄02) 𝐹(𝑣) = 𝜆𝑣3∇2/3
Onde 𝜆 é a constante dependente do motor instalado no navio, 𝑣 a
velocidade e ∇ é o deslocamento da embarcação;
15
A equação (𝑄02) fornece o consumo de uma embarcação de acordo
correlacionado com seu deslocamento, igualando esse consumo ao consumo
calculado pela otimização no primeiro passo tem-se:
(𝑄03) 𝐹𝑈𝐸𝐿𝑛,𝑣 = 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛𝐻𝑂𝑈𝑅𝑆𝑛 = 𝜆𝑣3∇n
23
Isso, seria para um trecho no próximo trecho tem-se 𝑛 + 1:
(𝑄04) 𝐹𝑈𝐸𝐿𝑛+1,𝑣 = 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛+1𝐻𝑂𝑈𝑅𝑆𝑛+1 = 𝜆𝑣3∇n+1
23
Pode-se então dividir (𝑄04)/(𝑄03) um pelo outro chegar em:
(𝑄05) 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛+1𝐻𝑂𝑈𝑅𝑆𝑛+1
𝑓𝑟𝑎𝑡𝑒𝑣,𝑛𝐻𝑂𝑈𝑅𝑆𝑛=
𝜆𝑣3∇n+1
23
𝜆𝑣3∇n
23
Assim, pode-se cortar 𝜆 e 𝑣 e chegar em:
(𝑄06) 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛+1 = 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛.𝐻𝑂𝑈𝑅𝑆𝑛
𝐻𝑂𝑈𝑅𝑆𝑛+1 . (
∇n+1
∇n)
2/3
Como o tempo em cada trecho se mantem o mesmo, devido a
simplificação feita, onde dividiu-se igualmente o tempo total por n, para
ter o tempo de cada trecho, então chega-se em:
(𝑄07) 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛+1 = 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛. (∇n+1
∇n)
2/3
Onde essa será a relação utilizada para realizar a atualização da
taxa de consumo para cada velocidade.
Ressalta-se que cada usuário é livre para escolher a relação de
atualização desejada, algumas embarcações possuem software de
cálculo da taxa de consumo, devido a isso o operador pode escolher
utilizar esse dado como fonte da taxa de consumo atualizada.
3.2. Modelagem do Problema
Apresentado o procedimento de dois passos a ser utilizado para permitir uma
solução linear para o problema e apresentado o modelo de programação linear base
16
para solução do primeiro passo e a relação matemática para atualização do
deslocamento e da taxa de consumo a ser utilizada no segundo passo, pode-se então
apresentar o modelo completo da solução do problema enunciado neste trabalho.
O método a ser apresentado tem como premissas a entrada das seguintes
informações, esses são os chamados dados de entrada:
• Dados da embarcação: Deslocamento inicial da embarcação, conjunto de
velocidade disponível, taxa de consumo de combustível para cada velocidade,
volume de combustível disponível para realizar a viagem.
• Dados da viagem: Distância total da rota, tempo máximo permitido.
• Discretização: valor desejado para qual rota seja dividida (N)
A solução do problema seguirá a seguinte modelagem:
1º Dados de entrada do problema: O usuário do programa irá imputar os dados de
entrada do problema, incluindo a discretização N desejada.
2º Divisão da Rota em N trechos: A rota será dividida em trechos, dado a
discretização N escolhida no primeiro passo, além da distância de cada trecho será
definido o tempo de cada trecho também, para isso dividirá o valor de entrada dos
dados da viagem por N.
3º Aplicação do procedimento de 2 passos (“Two step Procedure”) para cada
trecho, será realizado um loop de 𝑛 = 0 até 𝑛 = 𝑁, de forma que para cada trecho
𝑛: será realizada a modelagem e otimização do consumo de combustível para o
trecho. Desta forma, para cada trecho tem-se como resultado o consumo de
combustível e o conjunto de velocidades e respectivo tempo em cada velocidade
a ser desenvolvido pela embarcação para atingir o consumo calculado.
4º Resultado: Ao final da otimização de cada trecho é possível apresentar o
consumo total previsto para o problema em questão e o conjunto de velocidades e
tempo em cada velocidade proposto para cada trecho que minimiza o consumo de
combustível.
O modelo heurístico desenvolvido neste projeto é representado por meio do
fluxograma da figura 5:
17
Figura 5 - 3.2. Fluxograma do método heurístico proposto
Entendido o modelo, pode-se então apresentar as notações e equações que
compõem o modelo apresentado. A notação utilizada será o mais próximo da
utilizada por Brown [6] possível:
Index:
𝑣 ∈ 𝑉 → 𝑣 𝑟𝑒𝑝𝑟𝑒𝑠𝑒𝑛𝑡𝑎 𝑜 𝑛𝑎𝑣𝑖𝑜 𝑎𝑛𝑎𝑙𝑖𝑠𝑎𝑑𝑜 𝑒 𝑉 𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜 𝑑𝑒 𝑛𝑎𝑣𝑖𝑜𝑠;
𝑠 ∈ 𝑆 → 𝑠 é 𝑜 𝑖𝑛𝑑𝑒𝑥 𝑑𝑎 𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 𝑒 𝑆 𝑜 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒𝑠 𝑐𝑜𝑛𝑠𝑖𝑑𝑒𝑟𝑎𝑑𝑎;
18
𝑛 ∈ 𝑁 → 𝑛 é 𝑜 𝑖𝑛𝑑𝑒𝑥 𝑑𝑜 𝑡𝑟𝑒𝑐ℎ𝑜 𝑒 𝑁 é 𝑜 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑡𝑟𝑒𝑐ℎ𝑜𝑠 𝑐𝑜𝑛𝑠𝑖𝑑𝑒𝑟𝑎𝑑𝑜;
Por exemplo se o conjunto foi decidido analisar com 20 trechos, de um trajeto
que tem 20 milhas náuticas, assim N =20 e cada trecho tem 1 milha náutica, sendo
𝑛 = 1 o primeiro trecho que seria 01 milha náutica após o porto de partida.
Informações conhecidas e suas unidades:
𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑒 distância a ser percorrida entre os portos em milhas náuticas;
𝑠𝑝𝑒𝑒𝑑𝑠,𝑛 velocidade da embarcação em knots (milhas náuticas por hora) para cada
trecho 𝑛 e seu index 𝑠;
𝑓𝑟𝑎𝑡𝑒𝑣,𝑠,𝑛 taxa de consumo de combustível para a embarcação 𝑣 e para a velocidade
𝑠 de acordo com o trecho percorrido, valor dado em galões por hora;
𝑓𝑢𝑒𝑙𝑣 capacidade de armazenamento de combustível da embarcação 𝑣, dado em
Galões;
𝑟𝑒𝑠𝑒𝑟𝑣𝑒_𝑓𝑢𝑒𝑙𝑣 volume de combustível a ser reservado por quesitos de segurança,
dado em Galões;
ℎ𝑜𝑢𝑟𝑠 máximo de tempo em que a embarcação tem que completar a viagem, dado
em horas;
∇𝑛 é o deslocamento da embarcação após completar o trecho 𝑛
Variáveis do problema:
𝐻𝑂𝑈𝑅𝑆𝑠,𝑛 tempo gasto em cada velocidade 𝑠 em cada trecho n, dado em horas;
𝐻𝑂𝑈𝑅𝑆𝑠 tempo total gasto na viagem;
𝐹𝑈𝐸𝐿𝑣,𝑛 Total de combustível consumido durante o trecho n
𝐹𝑈𝐸𝐿𝑣 total de combustível consumido durante a viagem;
Apresentada a notação utilizada, pode-se então apresentar as equações que
modelam o programa, assim a modelagem é:
Variando 𝑛 = 1 𝑎 𝑛 = 𝑁
(𝐸0) 𝑀𝐼𝑁 𝐹𝑈𝐸𝐿𝑣,𝑛
19
(𝐸1) ∑ 𝑠𝑝𝑒𝑒𝑑𝑠,𝑛𝐻𝑂𝑈𝑅𝑆𝑆,𝑛 ≥𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑒
𝑁,
𝑠∈𝑆
(𝐸2) ∑ 𝐻𝑂𝑈𝑅𝑆𝑠,𝑛 ≤ℎ𝑜𝑢𝑟𝑠
𝑁,
𝑠∈𝑆
(𝐸3) 𝐹𝑈𝐸𝐿𝑣,𝑛 ≥ ∑ 𝑓𝑟𝑎𝑡𝑒𝑣,𝑠,𝑛−1𝐻𝑂𝑈𝑅𝑆𝑠,𝑛,
𝑠∈𝑆
(𝐸4) 𝐹𝑈𝐸𝐿𝑣,𝑛 ≤𝑓𝑢𝑒𝑙𝑣 − 𝑟𝑒𝑠𝑒𝑟𝑣𝑒𝑓𝑢𝑒𝑙𝑣
𝑁,
(𝐸5) 𝐻𝑂𝑈𝑅𝑆𝑠,𝑛 ≥ 0 ∀ 𝑠 ∈ 𝑆.
(𝐸6) ∇𝑛= ∇𝑛−1 − 𝐹𝑈𝐸𝐿𝑛−1. 𝜌
(𝐸7) 𝑓𝑟𝑎𝑡𝑒𝑣,𝑠,𝑛 = 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛. (∇n
∇n−1)
2/3
,
Após fazer todos os trechos 𝑛, calcula-se os valores finais:
(𝐸8) 𝐹𝑈𝐸𝐿𝑣 = ∑ 𝐹𝑈𝐸𝐿𝑣,𝑛 ,
𝑛∈𝑁
(𝐸9) 𝐻𝑂𝑈𝑅𝑆𝑣 = ∑ 𝐻𝑂𝑈𝑅𝑆𝑣,𝑛 ≥ ℎ𝑜𝑢𝑟𝑠,
𝑛∈𝑁
Como já explicado será feito uma otimização usando programação linear para
cada trecho 𝑛, desta forma em cada trecho a equação 𝐸0 é a função objetivo, a qual
deseja-se minimizar seu valor. 𝐸1 garante que a distância percorrida pela embarcação
seja maior ou igual a distância de cada trecho. A equação 𝐸2 garante que o tempo
percurso do trecho seja menor ou igual ao tempo máximo imposto para cada trecho.
A equação 𝐸3 calcula o total de combustível consumido dado o conjunto de tempo em
cada velocidade escolhido para o trecho 𝑛 analisado. A equação 𝐸4 garante que não
seja consumido mais combustível que o permitido para aquele trecho. E a equação
𝐸5 é uma restrição para evitar que o programa encontre a solução trivial do problema
que é tudo zero. Após rodar essas 5 equações a programação linear encontra uma
solução, ou seja, o valor de tempo para cada velocidade para aquele trecho que
resulta no menor consumo de combustível. Desta forma é possível com equação 𝐸6
calcular o novo deslocamento da embarcação após percorrer o trecho 𝑛 e posterior a
20
isso com a equação 𝐸7 é possível encontrar a taxa de consumo de cada velocidade
para o novo deslocamento. Faz-se isso para cada 𝑛 até chegar em 𝑛 = 𝑁. Após isso
calcula-se os valores totais de combustível consumido 𝐸8 e o tempo total da viagem
𝐸9.
21
4. Implementação Computacional
Para se implementar a metodologia apresentada foi escolhido dois softwares o
CPLEX e o EXCEL, dois softwares que possuem métodos de otimização linear, sendo,
respectivamente, um software muito mais robusto, sendo o estado da arte dos
softwares de otimização e o outro software mais simples, sendo usado no dia a dia da
computação. Desta forma, foi implementado computacionalmente no CPLEX
Optimizer que é programa de otimização linear de grande aceitação mundial e
utilizado por grandes empresas, pois o CPLEX é uma tecnologia criada pelo IBM
permitindo otimizar decisões de forma mais rápida e com possível menor custo, devido
a sua programação matemática de alto desempenho para programação linear, sendo
assim uma ferramenta poderosa para o nível empresarial. Posterior a implementação
no CPLEX, foi visto que a implementação no Excel seria benéfica, devido à grande
utilização do Excel pelos estudantes de engenharia, pela facilidade de instalação nas
embarcações, dado que toda embarcação já trabalha com Excel e na possibilidade de
criar de forma rápida e simples uma plataforma amigável para que qualquer leigo
possa entrar com os dados do problema e obter o resultado de em quais velocidade
e por quanto tempo em cada velocidade ele deve fazer aquele trajeto e a estimativa
do consumo total ao apertar de um botão.
Ressalto que isso é possível de ser feito com o CPLEX, porém demandaria um
conhecimento maior em programação para criar a interface gráfica e a aplicar junto
ao CPLEX, conhecimento esse que o autor já possuía de Excel. Devido a isso, foi
escolhido implementar em CPLEX, de forma básica, fazendo a atualização (passo 2)
de deslocamento e taxa de consumo utilizando outro programa e apenas a otimização
sendo realizada no CPLEX para que se tenha o estudo utilizando um software de peso
na área de otimização linear para que se evite dúvidas perante os resultados devido
ao software escolhido. Depois foi escolhido implementar no Excel para que fosse
desenvolvido uma plataforma amigável e de fácil replicação e instalação em várias
embarcações e que pudesse ter seus resultados corroborados pelos resultados do
CPLEX, desta forma ao utilizar o Excel foi possível sem demandar muito tempo que
leigos em programação, como comandantes e gerentes de frota, possam de forma
fácil e rápida utilizar o programa e calcular o melhor conjunto de velocidade e seus
respectivos tempo para minimizar o consumo de combustível .
22
4.1. Modelagem
A modelagem e o estudo de caso foram feitos utilizando o IBM ILOG CPLEX
Optimization Studio, Versão: 12.9.0.0, ID da construção: Community Edition, conforme
pode ser verificado pela imagem 6, retirada do software utilizado de novembro de 2019
a fevereiro de 2020 para gerar os dados.
A modelagem em Excel e VBA foi realizada utilizando Microsoft Excel para
Office 365 MSO - 64 bits (2017), e o VBA utilizado foi o Microsoft Visual Basic for
Applications 7.1, versão 1092, conforme pode ser verificado na imagem 7.
Figura 6 - 4.1. Janela de Dados sobre o IBM ILOG CPLEX Optimization Studio
Figura 7 - 4.1. Janela de dados sobre o VBA
A seguir será apresentado para cada software como o método apresentado no item
3. foi modelado no software em questão, como são colocados os dados de entrada,
como foi imposto as restrições, equações 𝐸1 𝑎 𝐸5, como a função objetivo 𝐸0 é
23
minimizada e por último como se dá a atualização das informações de deslocamento
e taxa de consume para cada trecho 𝐸6 𝑒 𝐸7.
4.1.1. Cplex
A modelagem no CPLEX será utilizada para realizar a otimização de
cada trecho (passo 1 do item 3.) e para cada trecho será utilizado uma
outra ferramenta para realizar a atualização dos dados de deslocamento
e taxa de consumo será utilizado outra ferramenta, escolhida pelo autor
como o Excel. Essa realização da solução utilizando dois programas é
devida ao pouco conhecimento do Autor com a programação em CPLEX
e necessidade de progredir com o projeto.
Para executar a otimização de cada trecho usando o CPLEX
modela-se o problema da seguinte forma: primeiro declara-se as variáveis
de entrada (Discretização “N”, quantidade de velocidade consideradas “S”,
as velocidades “speed”, distância a ser percorrida “distance”, tempo
máximo “hours”, combustível disponível “fuel”, deslocamento e a taxa de
consumo “frate”), também especifica-se se são valores inteiros (“int”) ou
decimais (“float”), se são um conjunto de valores ou valores únicos e após
isso entra-se com esses valores para o programa. Após isso, declara-se
as variáveis que são os valores que serão alterados e serão calculados
pela otimização. Com a declaração das entradas e das variáveis, define-
se a função objetivo (𝐸0) (consumo – “FUEL”) e o que se deseja fazer com
ela (minimizar – “minimize”) e posterior as restrições que devem ser
respeitadas (𝐸1 𝑎 𝐸4), onde 𝐸5 foi imposta ao se declarar a variável
“HOURS” com o sinal de +, o que impõe que a variável deve ser positiva,
ou seja, maior que 0.
• Modelagem (Passo 1 – Otimização do trecho):
//Parâmetros - INPUTS int N = N; int S = S; range speed = 1..S; float distance = distance; float Speed[speed] = [S1,S2,..,SS]; float hours = hours; float fuel = fuel-reserve; float deslocamento = deslocamento;
24
float frate[speed]=[frate1,frate2,..,FrateS]; //Variáveis de Decisão - OUTPUT dvar float+ HOURS[speed]; → 𝐸5 dvar float+ FUEL; //Função Objetivo minimize FUEL; → 𝐸0 //Restrições subject to { sum (s in speed) Speed[s]*HOURS[s]>=(distance/N); → 𝐸1 sum (s in speed) HOURS[s]<=(hours/N); → 𝐸2 sum (s in speed) frate[s]*HOURS[s]<=FUEL; → 𝐸3 FUEL<=(fuel/N); → 𝐸4
}
• Atualização do deslocamento e da taxa de consumo no Excel
Para se atualizar os valores do deslocamento e da taxa de
consumo após cada trecho otimizado, será calculado no Excel os valores
corrigidos usando as equações E6 e E7 apresentadas no item 3.
(𝐸6) ∇𝑛= ∇𝑛−1 − 𝐹𝑈𝐸𝐿𝑛−1. 𝜌
(𝐸7) 𝑓𝑟𝑎𝑡𝑒𝑣,𝑠,𝑛 = 𝑓𝑟𝑎𝑡𝑒𝑣,𝑛. (∇n
∇n−1)
2/3
,
Sendo que FUEL será calculado em galões pela otimização e
deverá ser convertido para metros cúbicos e posterior multiplicado pela
densidade do combustível usado.
Tabela 2 - 4.1.1. Tabela de atualização do deslocamento e da taxa de consumo após o trecho “n”
Correções
Trecho "Step" n
n
Deslocamentos
taxa de Consumo Tx1n Tx2n Tx3n Tx4n Tx5n Tx6n Tx7n Tx8n Tx9n
Tx10n
Tx11n
25
Após a atualização dos dados, entra-se com os novos dados no
CPLEX novamente e então otimiza-se o próximo trecho e repete-se esse
procedimento até finalizar a rota.
4.1.2. Excel A modelagem em Excel consiste na página de entrada de Dados,
onde o usuário irá imputar os dados da embarcação e da Rota, conforme
figura [8]. E escolherá qual a discretização N da rota desejada.
Figura 8 - 4.1.2. Tela de entrada de Dados da modelagem em EXCEL
Com os dados de entrada será calculado automaticamente os dados
de cada Trecho, conforme figura 9.
Figura 9 - 4.1.2. Tela de Calculo interno do programa para divisão da rota em trechos
Desta forma será utilizado o Solver [10] para fazer a otimização de
cada trecho, de forma que a modelagem do solver consistem em escolher
a função objetivo que se deseja “maximizar”, “minimizar” ou “chegar num
valor de”, como explicado no Item 3.2. a função objetivo desse projeto é o
consumo total de combustível, por isso a célula (B24) desta variável será
escolhida como função objetivo e será escolhida a função de minimizar
esse valor. Escolhido a função objetivo, escolhe-se quais dados serão
variáveis com o objetivo de se alcançar o menor consumo de combustível.
Deslocamento ton
Velocidades (knots) V1 V2 V3 V4 V5 V6 V7 V8 V9 V10 Vs
Consumos (gal/h) Tx1 Tx2 Tx3 Tx4 Tx5 Tx6 Tx7 Tx8 Tx9 Tx10 Txs
Vol. De combustivel Vmax gallons
Vol da reserva Vreserva gallons
Distancia total Dist m.n
Tempo total Tempo h
Discretização (N) N
Dados da Embarcação
Dados da Rota
Discretização Escolhida
ENTRADA DE DADOS - "INPUTS"
Número de Trechos
Distancia dos trechos m.n
Tempo por trechos h
Vol de combustivel
por trechosGallons
Dist / N
N
Dados dos Trechos
(Vmax - Vreserva)/N
TEMPO / N
26
Na modelagem apresentada essa Variável é o tempo em cada velocidade
(𝑇1, 𝑇2, 𝑇3, 𝑇4 … 𝑇𝑆) e por isso, será esse conjunto selecionado como valores
a serem alternados (B25 até L25).
Definido a função objetivo e as Variáveis do problema, define-se as
restrições que devem ser obedecidas, que no Item 3.2. apresentamos
como as equações 𝐸1 𝑎 𝐸5, para isso calculou-se cada equação conforme
será apresentado abaixo:
(𝐸1) ∑ 𝑠𝑝𝑒𝑒𝑑𝑠,𝑛𝐻𝑂𝑈𝑅𝑆𝑆,𝑛 ≥𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑒
𝑁,
𝑠∈𝑆
Utilizando a função soma produto, calculou-se em “I17” o valor de
∑ 𝑠𝑝𝑒𝑒𝑑𝑠,𝑛𝐻𝑂𝑈𝑅𝑆𝑆,𝑛𝑠∈𝑆 . Sendo assim a primeira linha das restrições;
Para se economizar tempo, uniu-se as restrições 𝐸3 e 𝐸4, pois como “a”
deve ser maior que “b” e “a” deve ser menor que “c”, por consequência
tem-se que “c” deve ser maior que “b”, assim tem-se que
(𝐸3) 𝐹𝑈𝐸𝐿𝑣,𝑛 ≥ ∑ 𝑓𝑟𝑎𝑡𝑒𝑣,𝑠,𝑛−1𝐻𝑂𝑈𝑅𝑆𝑠,𝑛,
𝑠∈𝑆
(𝐸4) 𝐹𝑈𝐸𝐿𝑣,𝑛 ≤𝑓𝑢𝑒𝑙𝑣 − 𝑟𝑒𝑠𝑒𝑟𝑣𝑒𝑓𝑢𝑒𝑙𝑣
𝑁,
𝑓𝑢𝑒𝑙𝑣 − 𝑟𝑒𝑠𝑒𝑟𝑣𝑒𝑓𝑢𝑒𝑙𝑣
𝑁≥ ∑ 𝑓𝑟𝑎𝑡𝑒𝑣,𝑠,𝑛−1𝐻𝑂𝑈𝑅𝑆𝑠,𝑛,
𝑠∈𝑆
E como por definição consumo é taxa de consumo vezes tempo,
então pode-se diminuir uma restrição, para simplificar os cálculos. Desta
forma em “I18” utilizando soma e produto, faz-se o somatório da taxa de
consumo vezes o tempo para cada velocidade e em “K18” calcula-se o
combustível disponível para aquele trecho. Desta forma a segunda linha
das restrições no solver, faz que 𝐼18 ≤ 𝐾18. Nas Células “I19” e “I20”
são calculados os somatórios de tempo, de forma a se respeitar as
equações 𝐸5 𝑒 𝐸2.
Essa modelagem no solver pode-se ser verificada nas figuras [10] e [11].
27
Figura 10 - 4.1.2. Tela do Excel com os dados de entrada, dados do trecho e as restições.
1 1 1 1 1 1 1 1 1 1 1
Deslocamento ton
Velocidades (knots) V1 V2 V3 V4 V5 V6 V7 V8 V9 V10 Vs
Consumos (gal/h) Tx1 Tx2 Tx3 Tx4 Tx5 Tx6 Tx7 Tx8 Tx9 Tx10 Txs
Vol. De combustivel Vmax gallons
Vol da reserva Vreserva gallons
Distancia total Dist m.n
Tempo total Tempo h
Discretização (N) N
Número de Trechos 0>= Dist / N E1
Distancia dos trechos m.n 0 < Comb. disp E3 e E4
Tempo por trechos h 0 > 0 E5
Comb. disp por trechos Gallons 0 <TEMPO /
NE2
Vol de combustivel consumido Votimiz. gallons m³ ton
Tempo por velocidade por trecho T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 Ts
ENTRADA DE DADOS - "INPUTS"Dados da Embarcação
Dados da Rota
Discretização Escolhida
(Vmax - Vreserva)/N
TEMPO / N
Resultados
Dados dos Trechos
Conversão m³ * Densidade
Restrições
Consumo X Tempo
Tempo por velocidade por trecho
Tempo por velocidade por trecho
Dist / N
N
Resolver Problema
28
Figura 11 - 4.1.2. Tela do Solver para se otimizar de forma linear (passo 1) mostrando como foi utilizado o Solver nessa modelagem
Essa é modelagem que será feita para cada otimização de consumo em cada
trecho no Passo 1 do método Heurístico apresentado no item 3. Ao se rodar o solver,
terá como resultado o conjunto de tempo em cada velocidade e o consumo daquele
trecho. Com auxílio do código de VBA [11] apresentado no Anexo 3, o programa de
Excel irá rodar o Solver, e após rodar o Solver, gravar o resultado para aquele trecho
e em seguida atualiza os dados de Deslocamento e de Taxa de consumo, conforme
as equações 𝐸6 e 𝐸7 e posterior a isso roda-se novamente o Solver para o próximo
trecho e assim por diante até terminar os N trechos. E ao Final será apresentado o
conjunto de tempo para cada trecho, o consumo em cada trecho e o consumo total.
Para executar esse código basta apertar o botão “Resolver problema” que ele irá
29
executar esse loop de ações (Passo 1 e Passo 2) para cada trecho e salvar os
resultados.
4.2. Estudo de Caso – Embarcação Seafighter
A seguir será apresentado o Caso estudado por Brown [6] em seu artigo e
seus resultados e em seguida será utilizado a mesma embarcação e os mesmos
dados de entrada do problema para se resolver utilizando o método Heurístico
apresentado em no item 3. Onde para mostrar a influência de se considerar o
deslocamento sob a curva de consumo, será estudado o caso N=1, onde o
resultado deverá ser igual ao de Brown, dado que não haverá atualização de
deslocamento e posterior será analisado casos onde se divide a rota em 2 trechos,
depois 3 trechos e vários outras Discretização da Rota (N=2, N=3, N=5, N=7,
N=10, N=15 e N=20) para se verificar o quanto a consideração do deslocamento
influência nos resultados e para se verificar a influência da discretização (N) da
rota, dado que quanto mais se discretiza mais se considera a variação do
deslocamento, pois considera-se que o deslocamento é constante para uma
distância menor.
Foi escolhido estudar a embarcação Seafighter devido ao fato dela já ter sido
estudada e modela por Brown [6], desta forma possibilitando uma aferição dos
resultados, podendo primeiro verificar que a otimização linear modelada está
correta quando roa-se o programa com N=1, desta forma não se considera a
variação do deslocamento e por isso o resultado alcançado pelos modelos em
CPLEX e EXCEL devem ser iguais ao de Brown [6], e posterior quando se
discretizar a rota pode-se comparar a estimativa encontrada com a estimativa sem
se considerar a variação do deslocamento.
4.2.1. Caso Modelo – Artigo do Brown de 2007 [6]
Brown apresenta um caso estudado que é o da embarcação SEA
FIGHTER, embarcação de deslocamento de 1.400 toneladas e que tem a
seguinte curva de consumo como mostrada na figura 12:
30
Figura 12 - 4.2.1. Curva de consumo da embarcação Sea Fighter para o deslocamento de 1400 ton utilizada por Brown [6]
A distância entre portos a ser percorrida é de 2.000 minhas náuticas, o
tempo máximo a ser realizado é de 65 horas. O volume de combustível
disponível para ser utilizado durante a viagem é de 159.500,00 galões e o
conjunto de velocidade escolhido foi 𝑆𝑝𝑒𝑒𝑑 =
(5; 7; 10; 12; 15; 20; 25; 30; 35; 40; 45; 50; 55);
Utilizando a modelagem apresentada por Brown o programa da marinha
chega que a embarcação deve realizar a viagem da seguinte forma: 30 horas
na velocidade de 20 knots e 35 horas na velocidade de 40 knots. Resultando
num consumo de 123.605 galões de combustível, conforme pode ser visto na
figura 13:
31
Figura 13 - 4.2.1. Tela de apresentação das entradas e resultados obtido por Brown em seu estudo de caso [6]
Vale ressaltar que Brown utiliza-se do Solver do Excel para resolver o
problema de maneira similar à que será apresentada no decorrer do projeto,
criando uma tela amigável em que é necessário apenas Imputar a distância
requerida, o tempo desejado, o volume de combustível disponível e a curva de
consumo da embarcação, que ao clicar em “Solve” o programa apresenta os
resultados.
4.2.2. Resultados pela modelagem no Cplex
A seguir será apresentado os resultados para as discretizações N=1,
N=2, N=3, N=5, N=7, N=10, N=15 e N=20. Onde o objetivo de se rodar a
rota em um único trecho N=1 é de se verificar que os resultados obtidos
pelo programa de otimização estão de acordo com os de Brown, dado que
ao se considerar a rota um único trecho não é levado em consideração a
variação do deslocamento e por isso os resultados devem ser iguais aos
de Brown.
Por efeito de apresentação e leitura, será apresentado em anexo as
tabelas e códigos de cada modelagem para cada estudo de Discretização.
32
Será apresentado apenas o código e resultado para N=1 e para N=2, para
que seja entendido o processo de aquisição de dados e o restante o
restante estará no anexo e poderá ser consultado.
4.2.2.1. Rota inteira sem considerar a variação de
deslocamento: N=1
A primeira vez que roda-se o programa, foi imputado os dados de entrada do
problema para o caso estudado e escolheu-se N=1, desta forma não será
considerado a variação de deslocamento e por isso espera-se encontrar os
mesmos dados de Brown [6];
• Entrada de Dados
//Parâmetros int N = 1; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5,3800,4750,5700]; //Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL; //Função Objetivo minimize FUEL; //Restrições subject to { sum (s in speed) Speed[s]*HOURS[s]>=(distance/N); sum (s in speed) HOURS[s]<=(hours/N); sum (s in speed) frate[s]*HOURS[s]<=FUEL; FUEL<=(fuel/N); }
33
• Resultado
FUEL = 1.236e+5; HOURS = [0 0 0 30 0 0 0 35 0 0 0];
O resultado encontrado pelo CPLEX foi o mesmo de Brown [6],
mostrando que o modelo de otimização está correto com o de Brown
[6].
4.2.2.2. Rota dividida em dois trechos: N=2
Agora, será escolhida a Discretização N=2, desta forma a rota será dividida
em 2 trechos, onde será feito a atualização do deslocamento e da curva de
consumo, desta forma espera se encontrar uma estimativa de consumo mais
real que a encontrada no caso anterior (N=1), pois em metade do caminho a
embarcação irá percorrer com a curva de consumo atualizada, dado sua
variação de deslocamento.
• Entrada de Dados para o Trecho n=1
//Parâmetros int N = 2; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700]; //Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL; //Função Objetivo minimize FUEL; //Restrições subject to { sum (s in speed) Speed[s]*HOURS[s]>=(distance/N); sum (s in speed)
34
HOURS[s]<=(hours/N); sum (s in speed) frate[s]*HOURS[s]<=FUEL; FUEL<=(fuel/N);
}
• Resultado para o Trecho n=1
FUEL = 61802; HOURS = [0 0 0 15 0 0 0 17.5 0 0 0];
• Atualização do deslocamento e taxa de consumo para o
Trecho n=1
Tabela 3 - 4.2.2.2. Tabela de correção após o trecho n=1, para rota dividida em 2 trechos
Deslocamento após o trecho n=1
1201,14 Ton Consumo no trecho n=1
61802,48 Gallons
Taxa de consumo após trecho n=1 90,29
180,58
451,46
552,05
1715,53 1986,40
2347,57
2715,50
3431,06
4288,83
5146,59
• Entrada de Dados para o Trecho n=2
//Parâmetros int N =2; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1201.14; float frate[speed]=[90.29,180.58,451.46,552.05,1715.53,1986.40,2347.57,2715.50,3431.06,4288.83,5146.59];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
35
sum (s in speed) frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
• Resultado para o Trecho n=2
FUEL = 55802; HOURS = [0 0 0 15 0 0 0 17.5 0 0 0];
• Volume total de consumo de combustível:
FUEL_TOTAL = 117604;
Conforme esperado foi calculado um volume de consumo de
combustível menor que o calculado sem considerar a variação da
curva de consumo, quando se atualiza a curva dado a variação do
deslocamento encontra-se 117 mil galões, já sem considerar o
deslocamento foi encontrado 123 mil.
Decide-se então discretizar a rota em vários trechos como pode ser
visto no Anexo 1, foi estudado a Discretização da rota em ( N=1, N=2,
N=3, N=5, N=7, N=10, N=15 e N=20).
4.2.3. Resultados pela modelagem no Excel
Será apresentado para cada resolução do problema os dados de
entradas utilizados e o resultado, sendo mostrado para cada trecho o tempo de
cada velocidade (Linha em vermelho da tabela de resultados) e por fim o
volume total de combustível e a diferença do consumo quando comparado a
otimização feita por Brown, apresentada no item 4.2.1.
A seguir será apresentado os resultados para as discretizações N=1,
N=2, N=3, N=5, N=7, N=10, N=15 e N=20. Onde o objetivo de se rodar a rota
em um único trecho N=1 é de se verificar que os resultados obtidos pelo
programa de otimização estão de acordo com os de Brown, dado que ao se
considerar a rota um único trecho não é levado em consideração a variação do
deslocamento e por isso os resultados devem ser iguais aos de Brown. E
posterior será rodado as rotas dividindo em 2 trechos, 3 trechos e assim por
36
diante para se verificar a melhora na estimava ao se discretizar mais a rota e
assim considerar mais o efeito da variação do deslocamento.
Por efeito de apresentação e leitura, será apresentado em anexo as
tabelas e códigos de cada modelagem para cada estudo de Discretização.
Será apresentado apenas o código e resultado para N=1 e para N=2, para que
seja entendido o processo de aquisição de dados e o restante o restante estará
no anexo 2 e poderá ser consultado.
4.2.3.1. Rota inteira sem considerar o deslocamento: N=1
A primeira vez que roda-se o programa, foi imputado os dados de entrada
do problema para o caso estudado e escolheu-se N=1, desta forma não será
considerado a variação de deslocamento e por isso espera-se encontrar os
mesmos dados de Brown [6];
Na tabela abaixo é visto os dados de entra da embarcação, da rota e a
Discretização N=1, e então aperta-se o botão para resolver o problema.
Tabela 4 - 4.2.3.1. Tela de entrada de dados para resolução do problema, rota sendo considerada um único trecho (N=1).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200
500 611
1900
2200
2600 3008
3800 4750
5700
Vol. De combustivel
159500
gallons
Vol da reserva 0 gallon
s
Dados da Rota
Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida
37
Desta forma, chega-se o mesmo resultado encontrado por Brown e pelo
resultado encontrado no CPLEX, mostrando que o Solver do EXCEL usando a
programação linear está modelado corretamente.
Tabela 5 - 4.2.3.1. Tela de resultados para cada trecho, na rota dividida em um único trecho.
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00
30,00 0,00 0,00 0,00 35,00 0,00 0,00 0,00
Deslocamento após o trecho n=1
1002,29 Ton
Consumo no trecho n=1
123605
Gallons
Taxa de consumo após trecho n=1 80,03
160,06 400,14
489,30
1520,54
1760,62
2080,73
2406,85
3041,07
3801,34
4561,61
Ainda é possível montar uma tabela com os dados finais obtidos e comparar
com o de Brown, obtendo uma discrepância de 0%.
Tabela 6 - 4.2.3.1. Tela de resultado final da rota, rota dividida em um único trecho.
Resultado Final N=1
Deslocamento Inicial 1400 ton
Discretização (N) 1
Dados dos Trechos
Restrições
Número de Trechos 1 2000
>= 2000 E1
Distancia dos trechos 2000 m.n
Taxa de Consumo X
Tempo 123605
<= 15950
0
E3 e
E4
Tempo por trechos 65 h
Tempo por velocidade por
trecho 65 > 0 E5
Comb. disp por trechos
159500 Gallon
s
Tempo por velocidade por
trecho 65 <= 65 E2
38
Deslocamento Final 1002,289 ton
Consumo Total 123605,0 gallons
Diferença Entre a otimização Simples 0,000% gallons
4.2.3.2. Rota dividida em dois trechos: N=2
Agora, será escolhida a Discretização N=2, desta forma a rota será
dividida em 2 trechos, onde será feito a atualização do deslocamento e da
curva de consumo, desta forma espera se encontrar uma estimativa de
consumo mais real que a encontrada no caso anterior (N=1), pois em
metade do caminho a embarcação irá percorrer com a curva de consumo
atualizada, dado sua variação de deslocamento.
Abaixo é imputado os dados da embarcação, da rota e a Discretização
de N=2.
Tabela 7 - 4.2.3.2. Tela de entrada de dados para resolução do problema, rota dividida em 2 trechos (N=2).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200 500 611 1900 2200 2600 3008
3800
4750
5700
Vol. De combustivel
159500
gallons
Vol da reserva 0 gallo
ns
Dados da Rota
Distância total
2000 m.n
Tempo total 65 h
Discretização Escolhida
39
Discretização (N) 2
Dados dos Trechos Restrições
Número de Trechos 2
1000
>= 100
0 E1
Distância dos trechos 1000 m.n
Taxa de Consumo X Tempo
61802,48
<= 79750
E3 e
E4 Tempo por trechos 32,5 h
Tempo por velocidade por trecho 32,5
> 0 E5
Comb. disp por trechos
79750 Gallo
ns Tempo por velocidade
por trecho 32,5 <= 32,5 E2
Tabela 8 - 4.2.3.2. Tela de resultados para cada trecho, na rota dividida em 2 trechos (N=2).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00
15,00 0,00 0,00 0,00 17,50 0,00 0,00 0,00
Deslocamento após o trecho n=1
1201,14 Ton
Consumo no trecho n=1 61802
Gallons
Taxa de consumo após trecho n=1 90,29
180,58 451,46
552,05
1715,53
1986,40
2347,57
2715,50
3431,06
4288,83
5146,59
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00
15,00 0,00 0,00 0,00 17,50 0,00 0,00 0,00
Deslocamento após o trecho n=2
1024,89 Ton
Consumo no trecho n=2
55802,12
Gallons
Taxa de consumo após trecho n=2 79,74
159,47 398,68
487,52
1514,98
1754,19
2073,13
2398,06
3029,96
3787,45
4544,94
Tabela 9 - 4.2.3.2. Tela de resultado final da rota, rota dividida em 2 trechos (N=2).
Resultado Final N=2
Deslocamento Inicial 1400 ton
Deslocamento Final 1024,892 ton
Consumo Total 117604,6 gallons
Diferença Entre a otimização Simples 4,855% gallons
40
Observa-se que ao se considerar a variação do deslocamento apenas
uma vez ao longo do trajeto a melhora na estimativa é de 4,8%.
Foi observado que o resultado da modelagem em CPLEX e EXCEL
são iguais, dessa forma será apresentado como um único resultado,
e a seguir será apresentado o resultado da modelagem para as
diferentes discretizações da rota realizada (N=3, N=5, N=7, N=10,
N=15 e N=20), sendo que ainda foi testado para N=50 e N=100 para
fim de fazer uma sensibilização e ao se verificar que o resultado foi
praticamente igual ao de N=20, foi escolhido parar em N=20, dado
que a rota é pequena e discretizar demais não trouxe vantagens.
Tabela 10 - 4.2.3.1. Tela de resultado final da rota, rota dividida em um único trecho.
Resultado Final N=1
Deslocamento Inicial 1400 ton
Deslocamento Final 1002,289 ton
Consumo Total 123605,0 gallons
Diferença Entre a otimização Simples 0,000% gallons
Tabela 11 - 4.2.3.2. Tela de resultado final da rota, rota dividida em 2 trechos (N=2).
Resultado Final N=2
Deslocamento Inicial 1400 ton
Deslocamento Final 1024,892 ton
Consumo Total 117604,6 gallons
Diferença Entre a otimização Simples 4,855% gallons
Tabela 12 - 4.2.3.3. Tela de resultado final da rota, rota dividida em 3 trechos (N=3).
Resultado Final N=3
Deslocamento Inicial 1400 ton
Deslocamento Final 1030,119 ton
Consumo Total 115513,9 gallons
Diferença Entre a otimização Simples 6,546% gallons
Tabela 13 - 4.2.3.4. Tela de resultado final da rota, rota dividida em 5 trechos (N=5).
Resultado Final N=5
Deslocamento Inicial 1400 ton
Deslocamento Final 1033,825 ton
Consumo Total 114031,9 gallons
Diferença Entre a otimização Simples 7,745% gallons
41
Tabela 14 - 4.2.3.5. Tela de resultado final da rota, rota dividida em 7 trechos (N=7).
Resultado Final N=7
Deslocamento Inicial 1400 ton
Deslocamento Final 1035,305 ton
Consumo Total 113465,8 gallons
Diferença Entre a otimização Simples 8,203% gallons
Tabela 15 - 4.2.3.6. Tela de resultado final da rota, rota dividida em 10 trechos (N=10).
Resultado Final N=10
Deslocamento Inicial 1400 ton
Deslocamento Final 1036,377 ton
Consumo Total 113072,5 gallons
Diferença Entre a otimização Simples 8,521% gallons
Tabela 16 - 4.2.3.7. Tela de resultado final da rota, rota dividida em 15 trechos (N=15).
Resultado Final N=15
Deslocamento Inicial 1400 ton
Deslocamento Final 1037,189 ton
Consumo Total 112786,4 gallons
Diferença Entre a otimização Simples 8,753% gallons
Tabela 17 - 4.2.3.8. Tela de resultado final da rota, rota dividida em 20 trechos (N=20).
Resultado Final N=20
Deslocamento Inicial 1400 ton
Deslocamento Final 1037,589 ton
Consumo Total 112650,2 gallons
Diferença Entre a otimização Simples 8,863% gallons
Dados os resultados para cada análise de Discretização, então analisa-se no próximo
tópico os resultados obtidos.
4.3. Análise dos Resultados
Pode-se verificar que os resultados obtidos pela implementação no CPLEX
e no Excel são idênticos, variando apenas nas últimas casas decimais devido ao
nível de aproximação estipulado para cada programa, como os resultados foram
os mesmos decidiu-se tratar como apenas um resultado. Os resultados
42
apresentados mostram para um único trecho (N=1), quando não se considera a
variação do deslocamento que o resultado é idêntico ao de Brown [6] e por isso
verifica-se que os métodos de otimização linear aplicados no “passo 1” foram
modelados corretamente. Já quando decide-se levar em consideração a variação
do deslocamento ao longo da rota, observa-se a melhora na estimativa do
consumo de combustível, assim pode-se observar que ao se considerar a variação
do deslocamento ao logo da rota o consumo de combustível estimado diminui, por
consequência o deslocamento final é um pouco maior, dado que se consumiu
menos combustível, ambas informações podem ser vistas respectivamente nas
figuras 14 e 15.
Figura 14 - 4.3. Gráfico de resumo de resultados do consumo total estimado para a embarcação Sea Fighter de acordo com a discretização N escolhida.
123605,0
117604,6
115513,9
114031,9113465,8
113072,5 112786,4 112650,2
112000,0
114000,0
116000,0
118000,0
120000,0
122000,0
124000,0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Co
nsu
mo
To
tal a
o f
inal
da
Ro
ta (
gallõ
es)
Discretização
Consumo Total para cada discretização
43
Figura 15 - 4.3. Gráfico de resumo de resultados do deslocamento final estimado da embarcação Sea Fighter de acordo com a discretização N escolhida.
Quando comparado o consumo calculado por Brown com o consumo calculado
pelo método proposto em função do nível de discretização escolhido, observa-se
que para essa rota a melhora na previsão do consumo assume um assíntota perto
do valor de N=20, ou seja, mostra que não é vantajoso discretizar infinitamente a
rota e para esse trecho de 2000 milhas náuticas, com N=20 é possível melhorar a
estimativa em quase 8,9%. Essa comparação do quanto melhora para cada nível
de discretização da rota é apresentada na figura 16.
1002,289
1024,892
1030,119
1033,8251035,305
1036,377 1037,189 1037,589
1002,000
1005,000
1008,000
1011,000
1014,000
1017,000
1020,000
1023,000
1026,000
1029,000
1032,000
1035,000
1038,000
1041,000
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
De
slo
cam
en
to a
o f
inal
da
Ro
ta (
Ton
s)
Discretização N
Deslocamento final para cada discretização
44
Figura 16 - 4.3. Gráfico de resumo do percentual de melhora na estimativa do consumo final da embarcação Sea Fighter de acordo com a discretização N escolhida.
Os resultados apresentados mostraram-se sólidos e confirmaram o esperado,
mostrando a melhora na previsão do combustível consumido ao se considerar a
variação da curva de consumo de combustível dado a variação do deslocamento
da embarcação.
0,000%
4,855%
6,546%
7,745%8,203%
8,521% 8,753% 8,863%
0,000%
1,000%
2,000%
3,000%
4,000%
5,000%
6,000%
7,000%
8,000%
9,000%
10,000%
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Dif
ere
nça
do
Re
sult
ado
de
Bro
wn
Discretização N
Melhora nos Resultados para cada discretização
45
5. Conclusão
Um método original foi apresentado para tratar o efeito da redução do
deslocamento de um navio na otimização da velocidade do navio em viagens
entre dois portos. O desempenho da heurística baseada em programação
linear proposta foi avaliado usando um estudo de caso do mundo real. É
demonstrado que isso pode resultar em uma redução de aproximadamente
9% no consumo de combustível em viagens de navios em comparação com
o caso em que a redução de deslocamento não é levada em consideração.
Algumas recomendações para novas áreas de pesquisa são as
seguintes. No primeiro, outros estudos de caso podem ser estudados para
longas rotas intercontinentais de navios. No segundo, a suposição de que a
capacidade do tanque de combustível do navio no início de um segmento
pode ser relaxada pelo desenvolvimento de um algoritmo iterativo apropriado.
A utilização desse modelo em graneleiros e mineraleiros podes ser uma
contribuição importante para projetos futuros, devido ao fato da rota ser muito
maior, desta forma um estudo se a influência do consumo de combustível na
curva de consumo seria significativa ou não. Psaraftis [12] mostra na figura do
gráfico abaixo que a curva de consumo para uma embarcação VLCC com
carga para somente com lastro muda cerca de 35%, desta forma vale ainda
aumentar o estudo para testar problemas considerando o embarque e
desembarque de cargas e o reabastecimento.
46
Figura 17 - 5. Curva de Consumo de um VLCC para a embarcação com carga ou só com Lastro. Fonte:[12]
Além disso, pode-se estudar realizar o procedimento de dois passos
utilizando outros métodos de otimização como um não linear e comparar com
esse trabalho. E por último, pode-se acrescentar uma variável ao problema
como a condição climática, ou o tipo de combustível utilizado ou a corrente do
mar e outros aspectos mostrados por Psaraftis and Kontovas [12] que
influencia na taxa de consumo.
47
Referências
[1] RESOLUÇÃO MEPC.203(62), adotada em 15 de julho de 2011, “Emendas
ao anexo do protocolo de 1997 que emenda a convenção internacional para a prevenção da
poluição por navios, 1973, como modificada pelo protocolo de 1978 a ela relativo” -
Inclusão de regras sobre eficiência energética para navios no Anexo VI da
MARPOL
[2] MENDONÇA, MÁRIO, et al 2018, “Eficiência Energética para Navios” –
Syndarma – Link acessado no dia 20/01/2020 as 11:35 a.m -
http://www.syndarma.org.br/upload/Efici__ncia%20Energ__tica%20para%20Navios_origin
al%20.pdf
[3] REIS VIRGINIO JUNIOR, LUIZ ALFREDO, et al. 2011, “Os efeitos causados
por tintas anti-incrustantes a base de compostos organoestânicos ao meio ambiente”,
Trabalho de conclusão de curso para o grau de Tecnólogo em Construção
Naval do Centro Universitário Estadual da Zona Oeste.
[4] Brandão, F. D., Avaliação de Impactos Econômicos e Operacionais em
Regime de Slow. Universidade Federal do Rio de Janeiro, Rio de Janeiro,
2013
[5] Slides 04 da Aula 04 “Estrutura de Custos do Transporte Marítimo”, Disciplina
Logística e Transporte Aquaviário / 2018 – Professor: Luiz Felipe Assis.
[6] BROWN, Gerald G. et al. “Steaming on convex hulls”. Interfaces, v. 37, n. 4,
p. 342-352, 2007.
[7] MERSIN, Kadir; ALKAN, Güler; MISIRLIOĞLU, Tunç. “A new method for
calculating fuel consumption and displacement of a ship in maritime
transport”. Cogent Engineering, v. 4, n. 1, p. 1415107, 2017.
[8] Ronen, D. (1982). “The effect of oil price on the optimal speed of ships”. Journal
of Operational Research, 33, 1035–1040.
https://doi.org/10.1057/jors.1982.215
[9] Barras, B. (2004). “Ship design and performance for masters and Mates”.
Oxford: Elsevier. ISBN 0-7506-6000-7.
[10] – Carregar o suplemento Solver no Excel – Link acessado no dia
25/01/2020 as 11:37 a.m. : https://support.office.com/pt-br/article/carregar-o-
suplemento-solver-no-excel-612926fc-d53b-46b4-872c-e24772f078ca
48
[11] – Mostrar a Guia de desenvolvedor (VBA) - Link acessado no dia
25/01/2020 as 11:39 a.m.: https://support.office.com/pt-br/article/mostrar-a-
guia-desenvolvedor-e1192344-5e56-4d45-931b-e5fd9bea2d45
[12] Psaraftis and Kontovas (2013) “Speed models for energy-efficient maritime
transportation: A taxonomy for energy-efficient maritime transportation: A taxonomy
and survey”. Transportation Research Part C, Vol.26, pp.331-351.
[13] Psaraftis and Kontovas (2014) “Ship speed optimization: concepts, models
and combined speed-routing scenarios”. Transportation Research Part C, Vol.44,
pp.52-69.
[14] Bialystocki and Konovessis (2016) “On the estimation of ship[´s fuel
consumption and speed curve: A statistical approach”. Journal og Ocean
Engineering and Science, vol.1, pp.157-166.
49
ANEXO 1
• Rota inteira sem considerar a variação de deslocamento: N=1
Entrada de Dados
//Parâmetros int N = 1; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5,3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado
FUEL = 1.236e+5; HOURS = [0 0 0 30 0 0 0 35 0 0 0];
• Rota dividida em dois trechos: N=2
Entrada de Dados para o Trecho n=1
//Parâmetros int N = 2;
50
int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=1
FUEL = 61802; HOURS = [0 0 0 15 0 0 0 17.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=1
Deslocamento após o trecho n=1
1201,14
Ton
Consumo no trecho n=1
61802,
48
Gallons
Taxa de consumo após trecho n=1
90,29
180,
58
451,
46
552,
05
1715,53
1986,40
2347,57
2715,50
3431,06
4288,83
5146,59
51
Entrada de Dados para o Trecho n=2
//Parâmetros int N =2; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1201.14; float frate[speed]=[90.29,180.58,451.46,552.05,1715.53,1986.40,2347.57,2715.50,3431.06,4288.83,5146.59];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=2
FUEL = 55802; HOURS = [0 0 0 15 0 0 0 17.5 0 0 0];
• Rota dividida em três trechos: N=3
Entrada de Dados para o Trecho n=1
52
//Parâmetros int N = 3; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=1
FUEL = 41202; HOURS = [0 0 0 10 0 0 0 11.667 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=1
Deslocamento após o trecho n=1
1267,43
Ton
Consumo no trecho n=1
4120
1,65
Gallons
Taxa de consumo após trecho n=1
93,58
18
7,17
46
7,92
57
2,18
1778,08
2058,83
2433,16
2814,51
3556,16
4445,20
5334,23
53
Entrada de Dados para o Trecho n=2
//Parâmetros int N =3; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1267.43; float frate[speed]=[93.58,187.17,467.92,572.18,1778.08,2058.83,2433.16,2814.51,3556.16,4445.20,5334.23];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=2
FUEL = 38558; HOURS = [0 0 0 10 0 0 0 11.667 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=2
Deslocamento após o trecho n=2
1144,27
Ton
Consumo no trecho n=2
3855
7,76
Gallons
Taxa de consumo
86,78
17
3,
43
3,
53
0,1648
1909,14
2256
2609
3297
4122
4946
54
após trecho n=2
56
90
58
,81
,26
,89
,61
,01
,42
Entrada de Dados para o Trecho n=3
//Parâmetros int N =3; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1144.27; float frate[speed]=[86.78,173.56,433.90,530.58, 1648.81,1909.14,2256.26,2609.89,3297.61,4122.01,4946.42];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=3
FUEL = 35754,5; HOURS = [0 0 0 10 0 0 0 11.667 0 0 0];
• Rota dividida em cinco trechos: N=5
Entrada de Dados para o Trecho n=1
55
//Parâmetros int N = 5; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=1
FUEL = 24721; HOURS = [0 0 0 6 0 0 0 7 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=1
Deslocamento após o trecho n=1
1320,46
Ton
Consumo no trecho n=1
2472
0,99
Gallons
Taxa de consumo após trecho n=1
96,18
19
2,35
48
0,88
58
8,03
1827,33
2115,86
2500,56
2892,48
3654,67
4568,33
5482,00
56
Entrada de Dados para o Trecho n=2
//Parâmetros int N =5; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1320.46; float frate[speed]=[96.18,192.35,480.88,588.03,1827.33, 2115.86,2500.56,2892.48,3654.67,4568.33,5482.00 ];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=2
FUEL = 23775,6; HOURS = [0 0 0 6 0 0 0 7 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=2
Deslocamento após o trecho n=2
1244,14
Ton
Consumo no trecho n=2
2377
5,53
Gallons
Taxa de consumo
92,21
18
4,
46
1,
56
3,1751
2028,61
2397
2773
3503
4379
5255
57
após trecho n=2
42
05
78
,98
,45
,20
,96
,95
,94
Entrada de Dados para o Trecho n=3
//Parâmetros int N =5; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1244.14; float frate[speed]=[92.21,184.42,461.05,563.78,1751.98,2028.61,2397.45,2773.20,3503.96,4379.95,5255.94];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=3
FUEL = 22795; HOURS = [0 0 0 6 0 0 0 7 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=3
58
Deslocamento após o trecho n=3
1170,98
Ton
Consumo no trecho n=3
2279
5,10
Gallons
Taxa de consumo após trecho n=3
88,34
17
6,67
44
1,68
54
0,10
1678,38
1943,39
2296,73
2656,70
3356,77
4195,96
5035,15
Entrada de Dados para o Trecho n=4
//Parâmetros int N =5; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1170.98; float frate[speed]=[88.34,176.67,441.68,540.10,1678.38,1943.39,2296.73,2656.70,3356.77,4195.96,5035.15];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=4
FUEL = 21837,5; HOURS = [0 0 0 6 0 0 0 7 0 0 0];
59
Atualização do deslocamento e taxa de consumo para o Trecho n=4
Deslocamento após o trecho n=4
1100,90
Ton
Consumo no trecho n=4
2183
7,52
Gallons
Taxa de consumo após trecho n=4
84,55
16
9,11
42
2,77
51
6,98
1606,54
1860,20
2198,42
2542,98
3213,07
4016,34
4819,61
Entrada de Dados para o Trecho n=5
//Parâmetros int N =5; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1100.90; float frate[speed]=[84.55,169.11,422.77,516.98,1606.54,1860.20,2198.42,2542.98,3213.07,4016.34,4819.61];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=5
60
FUEL = 20903; HOURS = [0 0 0 6 0 0 0 7 0 0 0];
• Rota dividida em sete trechos: N=7
Entrada de Dados para o Trecho n=1
//Parâmetros int N = 7; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=1
FUEL = 17658; HOURS = [0 0 0 4.2857 0 0 0 5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=1
61
Deslocamento após o trecho n=1
1343,18
Ton
Consumo no trecho n=1
1765
7,85
Gallons
Taxa de consumo após trecho n=1
97,28
19
4,55
48
6,38
59
4,76
1848,24
2140,07
2529,17
2925,57
3696,48
4620,60
5544,72
Entrada de Dados para o Trecho n=2
//Parâmetros int N =7; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1343.18; float frate[speed]=[97.28,194.55,486.38,594.76,1848.24,2140.07,2529.17,2925.57,3696.48,4620.60,5544.72];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=2
FUEL = 17177; HOURS = [0 0 0 4.2857 0 0 0 5 0 0 0];
62
Atualização do deslocamento e taxa de consumo para o Trecho n=2
Deslocamento após o trecho n=2
1287,98
Ton
Consumo no trecho n=2
1717
6,82
Gallons
Taxa de consumo após trecho n=2
94,48
18
8,96
47
2,40
57
7,66
1795,10
2078,54
2456,46
2841,46
3590,21
4487,76
5385,31
Entrada de Dados para o Trecho n=3
//Parâmetros int N =7; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1287.98; float frate[speed]=[94.48, 188.96, 472.40, 577.66, 1795.10, 2078.54, 2456.46, 2841.46, 3590.21, 4487.76, 5385.31];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=3
63
FUEL = 16683; HOURS = [0 0 0 4.2857 0 0 0 5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=3
Deslocamento após o trecho n=3
1234,37
Ton
Consumo no trecho n=3
1668
2,99
Gallons
Taxa de consumo após trecho n=3
91,73
18
3,45
45
8,63
56
0,83
1742,80
2017,98
2384,88
2758,67
3485,60
4357,00
5228,40
Entrada de Dados para o Trecho n=4
//Parâmetros int N =7; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[91.73, 183.45, 458.63, 560.83, 1742.80, 2017.98, 2384.88, 2758.67, 3485.60, 4357.00, 5228.40];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
64
Resultado para o Trecho n=4
FUEL = 16197; HOURS = [0 0 0 4.2857 0 0 0 5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=4
Deslocamento após o trecho n=4
1182,32
Ton
Consumo no trecho n=4
1619
6,89
Gallons
Taxa de consumo após trecho n=4
89,02
17
8,03
44
5,09
54
4,26
1691,33
1958,38
2314,45
2677,19
3382,65
4228,31
5073,98
Entrada de Dados para o Trecho n=5
//Parâmetros int N =7; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1182.32; float frate[speed]=[89.02, 178.03, 445.09, 544.26, 1691.33, 1958.38, 2314.45, 2677.19, 3382.65, 4228.31, 5073.98];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N);
65
}
Resultado para o Trecho n=5
FUEL = 15718; HOURS = [0 0 0 4.2857 0 0 0 5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=5
Deslocamento após o trecho n=5
1131,81
Ton
Consumo no trecho n=5
1571
8,51
Gallons
Taxa de consumo após trecho n=5
86,35
17
2,70
43
1,76
52
7,97
1640,68
1899,74
2245,14
2597,03
3281,36
4101,70
4922,05
Entrada de Dados para o Trecho n=6
//Parâmetros int N =7; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1131.81; float frate[speed]=[86.35, 172.70, 431.76, 527.97, 1640.68, 1899.74, 2245.14, 2597.03, 3281.36, 4101.70, 4922.05];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
66
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=6
FUEL = 15248; HOURS = [0 0 0 4.2857 0 0 0 5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=6
Deslocamento após o trecho n=6
1082,81
Ton
Consumo no trecho n=6
1524
7,85
Gallons
Taxa de consumo após trecho n=6
83,73
16
7,46
41
8,65
51
1,94
1590,87
1842,06
2176,98
2518,18
3181,73
3977,17
4772,60
Entrada de Dados para o Trecho n=7
//Parâmetros int N =7; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1082.81; float frate[speed]=[83.73, 167.46, 418.65, 511.94, 1590.87, 1842.06, 2176.98, 2518.18, 3181.73, 3977.17, 4772.60];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
67
sum (s in speed) Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed)
HOURS[s]<=(hours/N);
sum (s in speed) frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=7
FUEL = 14785; HOURS = [0 0 0 4.2857 0 0 0 5 0 0 0];
• Rota dividida em dez trechos: N=10
Entrada de Dados para o Trecho n=1
//Parâmetros int N = 10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
68
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=1
FUEL = 12360; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=1
Deslocamento após o trecho n=1
1360.23
Ton
Consumo no trecho n=1
1236
0.50
Gallons
Taxa de consumo após trecho n=1
98.10
19
6.19
49
0.49
59
9.78
1863.84
2158.14
2550.52
2950.27
3727.69
4659.61
5591.53
Entrada de Dados para o Trecho n=2
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1360.23; float frate[speed]=[98.097055699266,196.194111398532,490.48527849633,599.780113103667,1863.84405828605,2158.13522538385,2550.52344818091,2950.26895015542,3727.68811657211,4659.61014571513,5591.53217485816];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições
69
subject to {
sum (s in speed) Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed)
HOURS[s]<=(hours/N);
sum (s in speed) frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=2
FUEL = 12125; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=2
Deslocamento após o trecho n=2
1321.24
Ton
Consumo no trecho n=2
1212
5.28
Gallons
Taxa de consumo após trecho n=2
96.16
19
2.32
48
0.79
58
7.93
1827.01
2115.49
2500.12
2891.97
3654.02
4567.53
5481.03
Entrada de Dados para o Trecho n=3
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1321.24; float frate[speed]=[96.1584535198466,192.316907039693,480.792267599233,587.92720858837,1827.01061687709,2115.48597743663,2500.11979151601,2891.96548960939,3654.02123375417,4567.52654219271,5481.03185063126];
//Variáveis de Decisão dvar float+ HOURS[speed];
70
dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=3
FUEL = 11886; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=3
Deslocamento após o trecho n=3
1283.02
Ton
Consumo no trecho n=3
1188
5.66
Gallons
Taxa de consumo após trecho n=3
94.24
18
8.48
47
1.20
57
6.20
1790.56
2073.28
2450.24
2834.27
3581.13
4476.41
5371.69
Entrada de Dados para o Trecho n=4
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1283.02;
71
float frate[speed]=[94.2401729273463,188.480345854693,471.200864636731,576.198553303734,1790.56328561958,2073.28380440162,2450.244496111,2834.27320078994,3581.12657123916,4476.40821404895,5371.68985685874];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=4
FUEL = 11649; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=4
Deslocamento após o trecho n=4
1245.56
Ton
Consumo no trecho n=4
1164
8.55
Gallons
Taxa de consumo após trecho n=4
92.34
18
4.68
46
1.71
56
4.59
1754.50
2031.53
2400.90
2777.19
3509.00
4386.25
5263.51
Entrada de Dados para o Trecho n=5
//Parâmetros int N =10;
72
int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1245.56; float frate[speed]=[92.3422025582386,184.684405116477,461.711012791193,564.594077771454,1754.50184860653,2031.52845628125,2400.8972665142,2777.19174193903,3509.00369721307,4386.25462151633,5263.5055458196];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=5
FUEL = 11414; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=5
Deslocamento após o trecho n=5
1208.85
Ton
Consumo no trecho n=5
1141
3.95
Gallons
Taxa de consumo após trecho n=5
90.46
18
0.93
45
2.32
55
3.11
1718.83
1990.22
2352.08
2720.72
3437.65
4297.07
5156.48
73
Entrada de Dados para o Trecho n=6
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1208.85; float frate[speed]=[90.4645308248226,180.929061649645,452.322654124113,553.113711142589,1718.82608567163,1990.2196781461,2352.07780144539,2720.72076455654,3437.65217134326,4297.06521417907,5156.47825701489];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=6
FUEL = 11182; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=6
74
Deslocamento após o trecho n=6
1172.90
Ton
Consumo no trecho n=6
1118
1.86
Gallons
Taxa de consumo após trecho n=6
88.61
17
7.21
44
3.04
54
1.76
1683.54
1949.36
2303.79
2664.86
3367.07
4208.84
5050.61
Entrada de Dados para o Trecho n=7
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1172.90; float frate[speed]=[88.6071459086695,177.214291817339,443.035729543347,541.757381157492,1683.53577226472,1949.35720999073,2303.78579362541,2664.85991320324,3367.07154452944,4208.8394306618,5050.60731679416];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=7
FUEL = 10952; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
75
Atualização do deslocamento e taxa de consumo para o Trecho n=7
Deslocamento após o trecho n=7
1137.68
Ton
Consumo no trecho n=7
1095
2.28
Gallons
Taxa de consumo após trecho n=7
86.77
17
3.54
43
3.85
53
0.53
1648.63
1908.94
2256.02
2609.61
3297.26
4121.58
4945.89
Entrada de Dados para o Trecho n=8
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1137.68; float frate[speed]=[86.7700357538164,173.540071507633,433.850178769082,530.525014104197,1648.63067932251,1908.94078658396,2256.02092959923,2609.60882529603,3297.26135864502,4121.57669830628,4945.89203796754];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
76
Resultado para o Trecho n=8
FUEL = 10725; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=8
Deslocamento após o trecho n=8
1103.19
Ton
Consumo no trecho n=8
1072
5.21
Gallons
Taxa de consumo após trecho n=8
84.95
16
9.91
42
4.77
51
9.42
1614.11
1868.97
2208.78
2554.97
3228.22
4035.28
4842.33
Entrada de Dados para o Trecho n=9
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1103.19; float frate[speed]=[84.9531880596949,169.90637611939,424.765940298475,519.416534775184,1614.1105731342,1868.97013731329,2208.78288955207,2554.96713089532,3228.22114626841,4035.27643283551,4842.33171940261];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
77
FUEL<=(fuel/N); }
Resultado para o Trecho n=9
FUEL = 10501; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=9
Deslocamento após o trecho n=9
1069.43
Ton
Consumo no trecho n=9
1050
0.63
Gallons
Taxa de consumo após trecho n=9
83.16
16
6.31
41
5.78
50
8.43
1579.98
1829.44
2162.07
2500.93
3159.95
3949.94
4739.93
Entrada de Dados para o Trecho n=10
//Parâmetros int N =10; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1069.43; float frate[speed]=[83.1565902737814,166.313180547563,415.782951368907,508.43186642244,1579.97521520185,1829.44498602319,2162.07134711832,2500.93445248397,3159.95043040369,3949.93803800462,4739.92564560554];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
78
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=10
FUEL = 10279; HOURS = [0 0 0 3 0 0 0 3.5 0 0 0];
• Rota dividida em quinze trechos: N=15
Entrada de Dados para o Trecho n=1
//Parâmetros int N = 15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
79
FUEL<=(fuel/N); }
Resultado para o Trecho n=1
FUEL = 8240.3; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=1
Deslocamento após o trecho n=1
1373.49
Ton
Consumo no trecho n=1
8240.33
Gallons
Taxa de consumo após trecho n=1
98.73
19
7.47
49
3.67
60
3.67
1875.93
2172.13
2567.07
2969.41
3751.87
4689.84
5627.80
Entrada de Dados para o Trecho n=2
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1373.49; float frate[speed]=[98.7334059155761,197.466811831152,493.66702957788,603.670853778719,1875.93471239595,2172.13493014267,2567.06855380498,2969.40718291095,3751.86942479189,4689.83678098986,5627.80413718784];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
80
sum (s in speed)
HOURS[s]<=(hours/N);
sum (s in speed) frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=2
FUEL = 8136; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=2
Deslocamento após o trecho n=2
1347.31
Ton
Consumo no trecho n=2
8135.96
Gallons
Taxa de consumo após trecho n=2
97.45
19
4.90
48
7.25
59
5.83
1851.57
2143.92
2533.72
2930.84
3703.14
4628.92
5554.70
Entrada de Dados para o Trecho n=3
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1347.31; float frate[speed]=[97.4509288750483,194.901857750097,487.254644375242,595.829596781377,1851.56764862592,2143.92043525106,2533.72415075126,2930.83668591708,3703.13529725184,4628.9191215648,5554.70294587776];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize
81
FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=3
FUEL = 8030.3; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=3
Deslocamento após o trecho n=3
1321.48
Ton
Consumo no trecho n=3
8030.28
Gallons
Taxa de consumo após trecho n=3
96.18
19
2.35
48
0.89
58
8.04
1827.37
2115.90
2500.60
2892.53
3654.73
4568.41
5482.10
Entrada de Dados para o Trecho n=4
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1321.48; float frate[speed]=[96.177111501198,192.354223002396,480.88555750599,588.04128628505,1827.36511852276,2115.89645302636,2500.60489903115,2892.52662839853,3654.73023704552,4568.41279630691,5482.09535556829];
82
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=4
FUEL = 7925.3; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=4
Deslocamento após o trecho n=4
1295.99
Ton
Consumo no trecho n=4
7925.31
Gallons
Taxa de consumo após trecho n=4
94.91
18
9.82
47
4.56
58
0.31
1803.33
2088.06
2467.71
2854.48
3606.65
4508.32
5409.98
Entrada de Dados para o Trecho n=5
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65;
83
float fuel = 159500; float deslocamento = 1295.99; float frate[speed]=[94.911951795667,189.823903591334,474.559758978335,580.305910071477,1803.32708411767,2088.06293950467,2467.71074668734,2854.47695025468,3606.65416823534,4508.31771029418,5409.98125235302];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=5
FUEL = 7821.1; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=5
Deslocamento após o trecho n=5
1270.83
Ton
Consumo no trecho n=5
7821.06
Gallons
Taxa de consumo após trecho n=5
93.66
18
7.31
46
8.28
57
2.62
1779.45
2060.42
2435.04
2816.69
3558.91
4448.63
5338.36
Entrada de Dados para o Trecho n=6
84
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1270.83; float frate[speed]=[93.6554477340941,187.310895468188,468.27723867047,572.623455763411,1779.45350694779,2060.41985015007,2435.04164108645,2816.68759060288,3558.90701389557,4448.63376736947,5338.36052084336];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=6
FUEL = 7717.5; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=6
Deslocamento após o trecho n=6
1246.00
Ton
Consumo no trecho n=6
7717.52
Gallons
Taxa de consumo
92.41
18
4.
46
2.
56
4.1755
2032
2402
2779
3511
4389
5267
85
após trecho n=6
82
04
99
.74
.97
.60
.16
.49
.36
.23
Entrada de Dados para o Trecho n=7
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1246.00; float frate[speed]=[92.4075972656111,184.815194531222,462.037986328055,564.993910821536,1755.74434804661,2032.96713984344,2402.59752890589,2779.15848776325,3511.48869609322,4389.36087011653,5267.23304413983];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=7
FUEL = 7614.7; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=7
86
Deslocamento após o trecho n=7
1221.51
Ton
Consumo no trecho n=7
7614.69
Gallons
Taxa de consumo após trecho n=7
91.17
18
2.34
45
5.84
55
7.42
1732.20
2005.70
2370.38
2741.89
3464.40
4330.50
5196.60
Entrada de Dados para o Trecho n=8
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1221.51; float frate[speed]=[91.1683983123255,182.336796624651,455.841991561628,557.417262541305,1732.19956793418,2005.70476287116,2370.37835612046,2741.88957924319,3464.39913586837,4330.49891983546,5196.59870380255];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=8
FUEL = 7512.6; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
87
Atualização do deslocamento e taxa de consumo para o Trecho n=9
Deslocamento após o trecho n=8
1197.34
Ton
Consumo no trecho n=8
7512.58
Gallons
Taxa de consumo após trecho n=8
89.94
17
9.88
44
9.69
54
9.89
1708.82
1978.63
2338.38
2704.88
3417.64
4272.05
5126.46
Entrada de Dados para o Trecho n=9
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1197.34; float frate[speed]=[89.93784876879,179.87569753758,449.68924384395,549.893498049697,1708.81912660701,1978.63267291338,2338.38406798854,2704.88080172136,3417.63825321402,4272.04781651752,5126.45737982103];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
88
Resultado para o Trecho n=9
FUEL = 7411.2; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=9
Deslocamento após o trecho n=9
1173.50
Ton
Consumo no trecho n=9
7411.18
Gallons
Taxa de consumo após trecho n=9
88.72
17
7.43
44
3.58
54
2.42
1685.60
1951.75
2306.61
2668.13
3371.21
4214.01
5056.81
Entrada de Dados para o Trecho n=10
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1173.50; float frate[speed]=[88.7159465014578,177.431893002916,443.579732507289,542.422604301888,1685.6029835277,1951.75082303207,2306.6146090379,2668.13209103134,3371.20596705539,4214.00745881924,5056.80895058309];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
89
FUEL<=(fuel/N); }
Resultado para o Trecho n=10
FUEL = 7310.5; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=10
Deslocamento após o trecho n=10
1149.99
Ton
Consumo no trecho n=10
7310.49
Gallons
Taxa de consumo após trecho n=10
87.50
17
5.01
43
7.51
53
5.00
1662.55
1925.06
2275.07
2631.64
3325.10
4156.38
4987.65
Entrada de Dados para o Trecho n=11
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1149.99; float frate[speed]=[87.5026893481241,175.005378696248,437.513446740621,535.004568077833,1662.55109761436,1925.05916565873,2275.06992305123,2631.64338214483,3325.10219522872,4156.3777440359,4987.65329284308];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
90
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=11
FUEL = 7210.5; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=11
Deslocamento após o trecho n=11
1126.79
Ton
Consumo no trecho n=11
7210.51
Gallons
Taxa de consumo após trecho n=11
86.30
17
2.60
43
1.49
52
7.64
1639.66
1898.56
2243.75
2595.41
3279.33
4099.16
4918.99
Entrada de Dados para o Trecho n=12
/Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1126.79; float frate[speed]=[86.2980751173531,172.596150234706,431.490375586765,527.639375978764,1639.66342722971,1898.55765258177,2243.74995305118,2595.41460915439,3279.32685445942,4099.15856807427,4918.99028168912];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
91
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=12
FUEL = 7111.2; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=12
Deslocamento após o trecho n=12
1103.92
Ton
Consumo no trecho n=12
7111.25
Gallons
Taxa de consumo após trecho n=12
85.10
17
0.20
42
5.51
52
0.33
1616.94
1872.25
2212.65
2559.45
3233.88
4042.35
4850.82
Entrada de Dados para o Trecho n=13
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1103.92; float frate[speed]=[85.1021015878882,170.204203175776,425.510507939441,520.327014423587,1616.93993016988,1872.24623493354,2212.65464128509,2559.44570525574,3233.87986033975,4042.34982542469,4850.81979050963];
92
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=13
FUEL = 7012.7; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=13
Deslocamento após o trecho n=13
1081.36
Ton
Consumo no trecho n=13
7012.69
Gallons
Taxa de consumo após trecho n=13
83.91
16
7.83
41
9.57
51
3.07
1594.38
1846.12
2181.78
2523.74
3188.76
3985.95
4783.14
Entrada de Dados para o Trecho n=14
//Parâmetros int N =15; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1081.36;
93
float frate[speed]=[83.9147665080488,167.829533016098,419.573832540244,513.067469645187,1594.38056365293,1846.12486317707,2181.78392920927,2523.73660272957,3188.76112730586,3985.95140913232,4783.14169095878];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=14
FUEL = 6914.9; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=14
Deslocamento após o trecho n=14
1059.12
Ton
Consumo no trecho n=14
6914.85
Gallons
Taxa de consumo após trecho n=14
82.74
16
5.47
41
3.68
50
5.86
1571.99
1820.19
2151.14
2488.29
3143.97
3929.96
4715.96
Entrada de Dados para o Trecho n=15
//Parâmetros int N =15;
94
int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1059.12; float frate[speed]=[82.736067595109,165.472135190218,413.680337975545,505.860727686635,1571.98528430707,1820.1934870924,2151.13775747283,2488.2872329229,3143.97056861414,3929.96321076768,4715.95585292121];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=15
FUEL = 6817.7; HOURS = [0 0 0 2 0 0 0 2.3333 0 0 0];
• Rota dividida em vinte trechos: N=20
Entrada de Dados para o Trecho n=1
//Parâmetros int N = 20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65;
95
float fuel = 159500; float deslocamento = 1400; float frate[speed]=[100,200,500,611.4,1900,2200,2600,3007.5, 3800,4750,5700];
//Variáveis de Decisão dvar int+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=1
FUEL = 6180.2; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=1
Deslocamento após o trecho n=1
1380.11
Ton
Consumo no trecho n=1
6180.25
Gallons
Taxa de consumo após trecho n=1
99.05
19
8.10
49
5.25
60
5.61
1881.97
2179.12
2575.32
2978.95
3763.93
4704.91
5645.90
Entrada de Dados para o Trecho n=2
//Parâmetros int N =20; int S = 11;
96
range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1380.11; float frate[speed]=[99.0508128388013,198.101625677603,495.254064194006,605.611527318357,1881.96544393722,2179.11788245363,2575.32113380883,2978.95319612695,3763.93088787445,4704.91360984306,5645.89633181167];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=2
FUEL = 6121.6; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=2
Deslocamento após o trecho n=2
1360.42
Ton
Consumo no trecho n=2
6121.59
Gallons
Taxa de consumo após trecho n=2
98.09
19
6.19
49
0.46
59
9.75
1863.76
2158.04
2550.41
2950.14
3727.52
4659.40
5591.28
Entrada de Dados para o Trecho n=3
97
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1360.42; float frate[speed]=[98.0926825312344,196.185365062469,490.463412656172,599.753374898347,1863.76096809345,2158.03901568716,2550.4097458121,2950.13742712688,3727.52193618691,4659.40242023364,5591.28290428036];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=3
FUEL = 6062.4; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=3
Deslocamento após o trecho n=3
1340.92
Ton
Consumo no trecho n=3
6062.37
Gallons
Taxa de consumo após trecho n=3
97.14
19
4.28
48
5.70
59
3.92
1845.65
2137.07
2525.62
2921.47
3691.29
4614.12
5536.94
98
Entrada de Dados para o Trecho n=4
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1340.92; float frate[speed]=[97.1393225828668,194.278645165734,485.696612914334,593.924389170035,1845.64712907447,2137.06509682307,2525.62238715454,2921.46512667972,3691.29425814894,4614.11782268618,5536.94138722341];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=4
FUEL = 6003.5; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=4
Deslocamento após o trecho n=4
1321.60
Ton
Consumo no trecho n=4
6003.45
Gallons
Taxa de consumo
96.19
19
2.
48
0.
58
8.1827
2116
2500
2892
3655
4569
5482
99
após trecho n=4
38
95
12
.62
.20
.96
.94
.25
.06
.87
Entrada de Dados para o Trecho n=5
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1321.60; float frate[speed]=[96.190732396932,192.381464793864,480.95366198466,588.124566484702,1827.62391554171,2116.19611273251,2500.95904232023,2892.93627683773,3655.24783108342,4569.05978885427,5482.87174662513];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=5
FUEL = 5944.8; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=5
Deslocamento após o trecho n=5
1302
Ton
Consumo no trecho n=5
5944
Gallons
100
.48
.83
Taxa de consumo após trecho n=5
95.25
19
0.49
47
6.23
58
2.35
1809.69
2095.43
2476.42
2864.55
3619.38
4524.23
5429.07
Entrada de Dados para o Trecho n=6
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1302.48; float frate[speed]=[95.2469113708778,190.493822741756,476.234556854389,582.353903158252,1809.69131604668,2095.43205015931,2476.41969564282,2864.55085947915,3619.38263209336,4524.22829011669,5429.07394814003];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=6
FUEL = 5886.5; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=6
101
Deslocamento após o trecho n=6
1283.54
Ton
Consumo no trecho n=6
5886.49
Gallons
Taxa de consumo após trecho n=6
94.31
18
8.62
47
1.54
57
6.61
1791.85
2074.77
2452.00
2836.31
3583.70
4479.62
5375.55
Entrada de Dados para o Trecho n=7
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1283.54; float frate[speed]=[94.3078588962822,188.615717792564,471.539294481411,576.612395470704,1791.84931902936,2074.77289571821,2452.00433130334,2836.30885630569,3583.69863805872,4479.6232975734,5375.54795708808];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=7
FUEL = 5828.5; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
102
Atualização do deslocamento e taxa de consumo para o Trecho n=7
Deslocamento após o trecho n=7
1264.79
Ton
Consumo no trecho n=7
5828.46
Gallons
Taxa de consumo após trecho n=7
93.37
18
6.75
46
6.87
57
0.90
1774.10
2054.22
2427.71
2808.21
3548.20
4435.24
5322.29
Entrada de Dados para o Trecho n=8
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1264.79; float frate[speed]=[93.3735743587682,186.747148717536,466.867871793841,570.900039665663,1774.0979128166,2054.2186358929,2427.71293332797,2808.21024883995,3548.19582563319,4435.24478204149,5322.29373844979];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=8
103
FUEL = 5770.7; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=8
Deslocamento após o trecho n=8
1246.22
Ton
Consumo no trecho n=8
5770.72
Gallons
Taxa de consumo após trecho n=8
92.44
18
4.89
46
2.22
56
5.22
1756.44
2033.77
2403.55
2780.26
3512.87
4391.09
5269.31
Entrada de Dados para o Trecho n=9
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1246.22; float frate[speed]=[92.444057137917,184.888114275834,462.220285689585,565.216831949795,1756.43708562042,2033.76925703417,2403.54548558584,2780.25501842285,3512.87417124085,4391.09271405106,5269.31125686127];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
104
Resultado para o Trecho n=9
FUEL = 5713.3; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=9
Deslocamento após o trecho n=9
1227.84
Ton
Consumo no trecho n=9
5713.27
Gallons
Taxa de consumo após trecho n=9
91.52
18
3.04
45
7.60
55
9.56
1738.87
2013.42
2379.50
2752.44
3477.73
4347.17
5216.60
Entrada de Dados para o Trecho n=10
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1227.84; float frate[speed]=[91.5193066071786,183.038613214357,457.596533035893,559.562768492281,1738.86682553639,2013.42474535793,2379.50197178664,2752.4431462109,3477.73365107279,4347.16706384098,5216.60047660918];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
105
FUEL<=(fuel/N); }
Resultado para o Trecho n=10
FUEL = 5656.1; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=10
Entrada de Dados para o Trecho n=11
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1209.65; float frate[speed]=[90.599322133782,181.198644267564,452.99661066891,553.937845424263,1721.38712054186,1993.1850869432,2355.58237547833,2724.77461317349,3442.77424108372,4303.46780135464,5164.16136162557];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed)
Deslocamento após o trecho n=10
1209.65
Ton
Consumo no trecho n=10
5656.12
Gallons
Taxa de consumo após trecho n=10
90.60
18
1.20
45
3.00
55
3.94
1721.39
1993.19
2355.58
2724.77
3442.77
4303.47
5164.16
106
HOURS[s]<=(hours/N);
sum (s in speed) frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=11
FUEL = 5599.3; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=11
Deslocamento após o trecho n=11
1191.63
Ton
Consumo no trecho n=11
5599.26
Gallons
Taxa de consumo após trecho n=11
89.68
17
9.37
44
8.42
54
8.34
1704.00
1973.05
2331.79
2697.25
3408.00
4259.99
5111.99
Entrada de Dados para o Trecho n=12
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1191.63; float frate[speed]=[89.6841030786426,179.368206157285,448.420515393213,548.342058838282,1703.99795849421,1973.05026773014,2331.78668004471,2697.24940009018,3407.99591698842,4259.99489623552,5111.99387548263];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
107
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=12
FUEL = 5542.7; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=12
Deslocamento após o trecho n=12
1173.80
Ton
Consumo no trecho n=12
5542.70
Gallons
Taxa de consumo após trecho n=12
88.77
17
7.55
44
3.87
54
2.78
1686.70
1953.02
2308.11
2669.87
3373.40
4216.75
5060.10
Entrada de Dados para o Trecho n=13
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1173.80; float frate[speed]=[88.7736487962683,177.547297592537,443.868243981341,542.775404787704,1686.6993271291,1953.0202735179,2308.11486870297,2669.86748754777,3373.39865425819,4216.74831782274,5060.09798138729];
108
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=13
FUEL = 5486.4; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=13
Deslocamento após o trecho n=13
1156.15
Ton
Consumo no trecho n=13
5486.43
Gallons
Taxa de consumo após trecho n=13
87.87
17
5.74
43
9.34
53
7.24
1669.49
1933.10
2284.57
2642.63
3338.98
4173.73
5008.47
Entrada de Dados para o Trecho n=14
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65;
109
float fuel = 159500; float deslocamento = 1156.15; float frate[speed]=[87.8679586346634,175.735917269327,439.339793173317,537.237879286127,1669.4912140586,1933.0950899626,2284.56692450125,2642.6288559375,3338.98242811721,4173.72803514651,5008.47364217581];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=14
FUEL = 5430.5; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=14
Deslocamento após o trecho n=14
1138.68
Ton
Consumo no trecho n=14
5430.46
Gallons
Taxa de consumo após trecho n=14
86.97
17
3.93
43
4.84
53
1.73
1652.37
1913.27
2261.14
2615.53
3304.75
4130.93
4957.12
Entrada de Dados para o Trecho n=15
//Parâmetros int N =20; int S = 11;
110
range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1138.68; float frate[speed]=[86.9670319352311,173.934063870462,434.835159676155,531.729478306793,1652.37360676939,1913.27470257508,2261.14283031601,2615.53348545207,3304.74721353878,4130.93401692348,4957.12082030817];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=15
FUEL = 5374.8; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=15
Deslocamento após o trecho n=15
1121.39
Ton
Consumo no trecho n=15
5374.78
Gallons
Taxa de consumo após trecho n=15
86.07
17
2.14
43
0.35
52
6.25
1635.35
1893.56
2237.84
2588.58
3270.69
4088.37
4906.04
Entrada de Dados para o Trecho n=16
111
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1121.39; float frate[speed]=[86.0708680326732,172.141736065346,430.354340163366,526.250197781969,1635.34649262079,1893.55909671881,2237.8425688495,2588.58135608265,3270.69298524158,4088.36623155198,4906.03947786237];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=16
FUEL = 5319.4; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=16
Deslocamento após o trecho n=16
1104.28
Ton
Consumo no trecho n=16
5319.39
Gallons
Taxa de consumo após trecho n=16
85.18
17
0.36
42
5.90
52
0.80
1618.41
1873.95
2214.67
2561.77
3236.82
4046.02
4855.23
112
Entrada de Dados para o Trecho n=17
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1104.28; float frate[speed]=[85.1794662548889,170.358932509778,425.897331274445,520.800033602329,1618.40985884289,1873.94825760756,2214.66612262711,2561.77244761578,3236.81971768578,4046.02464710722,4855.22957652867];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=17
FUEL = 5264.3; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=17
Deslocamento após o trecho n=17
1087.34
Ton
Consumo no trecho n=17
5264.30
Gallons
113
Taxa de consumo após trecho n=17
84.29
16
8.59
42
1.46
51
5.38
1601.56
1854.44
2191.61
2535.11
3203.13
4003.91
4804.69
Entrada de Dados para o Trecho n=18
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1087.34; float frate[speed]=[84.2928259228705,168.585651845741,421.464129614353,515.378981616319,1601.56369253454,1854.44217030315,2191.61347399463,2535.10673963033,3203.12738506908,4003.90923133635,4804.69107760362];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=18
FUEL = 5209.5; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
Atualização do deslocamento e taxa de consumo para o Trecho n=18
114
Deslocamento após o trecho n=18
1070.58
Ton
Consumo no trecho n=18
5209.51
Gallons
Taxa de consumo após trecho n=18
83.41
16
6.82
41
7.05
50
9.99
1584.81
1835.04
2168.68
2508.58
3169.62
3962.02
4754.42
Entrada de Dados para o Trecho n=19
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1070.58; float frate[speed]=[83.4109463505977,166.821892701195,417.054731752988,509.987037629507,1584.80798066136,1835.04081971315,2168.68460511554,2508.58421149423,3169.61596132271,3962.01995165339,4754.42394198407];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=19
FUEL = 5155; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
115
Atualização do deslocamento e taxa de consumo para o Trecho n=19
Deslocamento após o trecho n=19
1054.00
Ton
Consumo no trecho n=19
5155.00
Gallons
Taxa de consumo após trecho n=19
82.53
16
5.07
41
2.67
50
4.62
1568.14
1815.74
2145.88
2482.20
3136.29
3920.36
4704.43
Entrada de Dados para o Trecho n=20
//Parâmetros int N =20; int S = 11; range speed = 1..S; float distance = 2000; float Speed[speed] = [5,10,15,20,25,30,35,40,45,50,55]; float hours = 65; float fuel = 159500; float deslocamento = 1054.00; float frate[speed]=[82.5338268449292,165.067653689858,412.669134224646,504.624197403924,1568.14271005366,1815.74419058844,2145.87949796816,2482.20484236125,3136.28542010731,3920.35677513414,4704.42813016097];
//Variáveis de Decisão dvar float+ HOURS[speed]; dvar float+ FUEL;
//Função Objetivo minimize FUEL;
//Restrições subject to {
sum (s in speed)
Speed[s]*HOURS[s]>=(distance/N);
sum (s in speed) HOURS[s]<=(hours/N);
sum (s in speed)
frate[s]*HOURS[s]<=FUEL;
FUEL<=(fuel/N); }
Resultado para o Trecho n=20
FUEL = 5100.8; HOURS = [0 0 0 1.5 0 0 0 1.75 0 0 0];
116
ANEXO 2
Rota dividida em um único trecho: N=1
Tabela 18 - 4.2.3.1. Tela de entrada de dados para resolução do problema, rota sendo considerada um único trecho (N=1).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200
500 611
1900
2200
2600 3008
3800 4750
5700
Vol. De combustivel
159500
gallons
Vol da reserva 0 gallon
s
Dados da Rota
Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida Discretização
(N) 1
Dados dos Trechos
Restrições
Número de Trechos 1 2000
>= 2000 E1
Distancia dos trechos 2000 m.n
Taxa de Consumo X
Tempo 123605
<= 15950
0
E3 e
E4
Tempo por trechos 65 h
Tempo por velocidade por
trecho 65 > 0 E5
Comb. disp por trechos
159500 Gallon
s
Tempo por velocidade por
trecho 65 <= 65 E2
117
Tabela 19 - 4.2.3.1. Tela de resultados para cada trecho, na rota dividida em um único trecho.
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00
30,00 0,00 0,00 0,00 35,00 0,00 0,00 0,00
Deslocamento após o trecho n=1
1002,29 Ton
Consumo no trecho n=1
123605
Gallons
Taxa de consumo após trecho n=1 80,03
160,06 400,14
489,30
1520,54
1760,62
2080,73
2406,85
3041,07
3801,34
4561,61
Tabela 20 - 4.2.3.1. Tela de resultado final da rota, rota dividida em um único trecho.
Resultado Final N=1
Deslocamento Inicial 1400 ton
Deslocamento Final 1002,289 ton
Consumo Total 123605,0 gallons
Diferença Entre a otimização Simples 0,000% gallons
• Rota dividida em dois trechos: N=2
Tabela 21 - 4.2.3.2. Tela de entrada de dados para resolução do problema, rota dividida em 2 trechos (N=2).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200 500 611 1900 2200 2600 3008
3800
4750
5700
Vol. De combustivel
159500
gallons
Vol da reserva 0 gallo
ns
Dados da Rota
Distância total
2000 m.n
Tempo total 65 h
118
Discretização Escolhida Discretização
(N) 2
Dados dos Trechos Restrições
Número de Trechos 2
1000
>= 100
0 E1
Distância dos trechos 1000 m.n
Taxa de Consumo X Tempo
61802,48
<= 79750
E3 e
E4 Tempo por trechos 32,5 h
Tempo por velocidade por trecho 32,5
> 0 E5
Comb. disp por trechos
79750 Gallo
ns Tempo por velocidade
por trecho 32,5 <= 32,5 E2
Tabela 22 - 4.2.3.2. Tela de resultados para cada trecho, na rota dividida em 2 trechos (N=2).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00
15,00 0,00 0,00 0,00 17,50 0,00 0,00 0,00
Deslocamento após o trecho n=1
1201,14 Ton
Consumo no trecho n=1 61802
Gallons
Taxa de consumo após trecho n=1 90,29
180,58 451,46
552,05
1715,53
1986,40
2347,57
2715,50
3431,06
4288,83
5146,59
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00
15,00 0,00 0,00 0,00 17,50 0,00 0,00 0,00
Deslocamento após o trecho n=2
1024,89 Ton
Consumo no trecho n=2
55802,12
Gallons
Taxa de consumo após trecho n=2 79,74
159,47 398,68
487,52
1514,98
1754,19
2073,13
2398,06
3029,96
3787,45
4544,94
Tabela 23 - 4.2.3.2. Tela de resultado final da rota, rota dividida em 2 trechos (N=2).
Resultado Final N=2
Deslocamento Inicial 1400 ton
Deslocamento Final 1024,892 ton
119
Consumo Total 117604,6 gallons
Diferença Entre a otimização Simples 4,855% gallons
Rota dividida em três trechos: N=3
Tabela 24 - 4.2.3.3. Tela de entrada de dados para resolução do problema, rota dividida em 3 trechos (N=3).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200 500 611 1900
2200
2600 3008
3800 4750
5700
Vol. De combustivel
159500
gallons
Vol da reserva 0 gallo
ns
Dados da Rota
Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida
Discretização (N) 3
Dados dos Trechos Restrições
Número de Trechos 3
666,666
7
>= 666,66
67 E1
Distância dos trechos 666,6666667 m.n
Taxa de Consumo X Tempo
41201,65
<= 53166,
67
E3 e
E4
Tempo por trechos 21,66666667 h
Tempo por velocidade por
trecho 21,6666
7 > 0 E5
Comb. disp por trechos
53166,66667 Gallo
ns
Tempo por velocidade por
trecho 21,6666
7 <=
21,66667
E2
120
Tabela 25 - 4.2.3.3. Tela de resultados para cada trecho, na rota dividida em 3 trechos (N=3).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00 10,00 0,00 0,00 0,00 11,67 0,00 0,00 0,00
Deslocamento após o trecho n=1
1267,43 Ton
Consumo no trecho n=1
41201,65 Gallons
Taxa de consumo após trecho n=1 93,58
187,17 467,92
572,18
1778,08 2058,83
2433,16
2814,51
3556,16
4445,20
5334,23
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00 10,00 0,00 0,00 0,00 11,67 0,00 0,00 0,00
Deslocamento após o trecho n=2
1144,27 Ton
Consumo no trecho n=2
38557,76 Gallons
Taxa de consumo após trecho n=2 86,78
173,56 433,90
530,58
1648,81 1909,14
2256,26
2609,89
3297,61
4122,01
4946,42
Tempo em cada vel. para o trecho n=3 0,00 0,00 0,00 10,00 0,00 0,00 0,00 11,67 0,00 0,00 0,00
Deslocamento após o trecho n=3
1030,12 Ton
Consumo no trecho n=3
35754,48 Gallons
Taxa de consumo após trecho n=3 80,28
160,56 401,41
490,85
1525,34 1766,19
2087,31
2414,46
3050,69
3813,36
4576,03
Tabela 26 - 4.2.3.3. Tela de resultado final da rota, rota dividida em 3 trechos (N=3).
Resultado Final N=3
Deslocamento Inicial 1400 ton
Deslocamento Final 1030,119 ton
Consumo Total 115513,9 gallons
Diferença Entre a otimização Simples 6,546% gallons
121
Rota dividida em cinco trechos: N=5
Tabela 27 - 4.2.3.4. Tela de entrada de dados para resolução do problema, rota dividida em 5 trechos (N=5).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200 500 611 190
0 220
0 260
0 3008 380
0 4750 570
0
Vol. De combustivel 15950
0 gallon
s
Vol da reserva 0 gallon
s
Dados da Rota Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida
Discretização (N) 5
Dados dos Trechos
Restrições
Número de Trechos 5 400 >= 400 E1
Distância dos trechos 400 m.n
Taxa de Consumo X
Tempo 24720,9
9 <=
31900
E3 e E4
Tempo por trechos 13 h
Tempo por velocidade por
trecho 13 > 0 E5
Comb. disp por trechos
31900 Gallon
s
Tempo por velocidade por
trecho 13 <= 13 E2
Tabela 28 - 4.2.3.4. Tela de resultados para cada trecho, na rota dividida em 5 trechos (N=5).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
122
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00 6,00 0,00 0,00 0,00 7,00 0,00 0,00 0,00
Deslocamento após o trecho n=1
1320,46 Ton
Consumo no trecho n=1
24720,99
Gallons
Taxa de consumo após trecho n=1 96,18
192,35 480,88
588,03
1827,33
2115,86
2500,56
2892,48
3654,67
4568,33
5482,00
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00 6,00 0,00 0,00 0,00 7,00 0,00 0,00 0,00
Deslocamento após o trecho n=2
1244,14 Ton
Consumo no trecho n=2
23775,53
Gallons
Taxa de consumo após trecho n=2 92,21
184,42 461,05
563,78
1751,98
2028,61
2397,45
2773,20
3503,96
4379,95
5255,94
Tempo em cada vel. para o trecho n=3 0,00 0,00 0,00 6,00 0,00 0,00 0,00 7,00 0,00 0,00 0,00
Deslocamento após o trecho n=3
1170,98 Ton
Consumo no trecho n=3
22795,10
Gallons
Taxa de consumo após trecho n=3 88,34
176,67 441,68
540,10
1678,38
1943,39
2296,73
2656,70
3356,77
4195,96
5035,15
Tempo em cada vel. para o trecho n=4 0,00 0,00 0,00 6,00 0,00 0,00 0,00 7,00 0,00 0,00 0,00
Deslocamento após o trecho n=4
1100,90 Ton
Consumo no trecho n=4
21837,52
Gallons
Taxa de consumo após trecho n=4 84,55
169,11 422,77
516,98
1606,54
1860,20
2198,42
2542,98
3213,07
4016,34
4819,61
Tempo em cada vel. para o trecho n=5 0,00 0,00 0,00 6,00 0,00 0,00 0,00 7,00 0,00 0,00 0,00
Deslocamento após o trecho n=5
1033,83 Ton
Consumo no trecho n=5
20902,72
Gallons
Taxa de consumo após trecho n=5 80,87
161,73 404,33
494,42
1536,44
1779,03
2102,49
2432,02
3072,87
3841,09
4609,31
Tabela 29 - 4.2.3.4. Tela de resultado final da rota, rota dividida em 5 trechos (N=5).
Resultado Final N=5
Deslocamento Inicial 1400 ton
Deslocamento Final 1033,825 ton
Consumo Total 114031,9 gallons
Diferença Entre a otimização Simples 7,745% gallons
Rota dividida em sete trechos: N=7
Tabela 30 - 4.2.3.5. Tela de entrada de dados para resolução do problema, rota dividida em 7 trechos (N=7).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
123
Consumos (gal/h) 100 200 500 611 190
0 220
0 260
0 3008 380
0 4750 570
0
Vol. De combustivel
159500
gallons
Vol da reserva 0 gallo
ns
Dados da Rota Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida
Discretização (N) 7
Dados dos Trechos
Restrições
Número de Trechos 7
285,7143
>= 285,71
43 E1
Distância dos trechos 285,7142857 m.n
Taxa de Consumo X
Tempo 17657,
85 <=
22785,71
E3 e E4
Tempo por trechos 9,285714286 h
Tempo por velocidade por
trecho 9,2857
14 > 0 E5
Comb. disp por trechos
22785,71429 Gallo
ns
Tempo por velocidade por
trecho 9,2857
14 <=
9,285714
E2
Tabela 31 - 4.2.3.5. Tela de resultados para cada trecho, na rota dividida em 7 trechos (N=7).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00 4,29 0,00 0,00 0,00 5,00 0,00 0,00 0,00
Deslocamento após o trecho n=1
1343,18 Ton
Consumo no trecho n=1
17657,85
Gallons
Taxa de consumo após trecho n=1 97,28
194,55 486,38
594,76
1848,24
2140,07
2529,17
2925,57
3696,48
4620,60
5544,72
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00 4,29 0,00 0,00 0,00 5,00 0,00 0,00 0,00
Deslocamento após o trecho n=2
1287,98 Ton
Consumo no trecho n=2
17176,82
Gallons
124
Taxa de consumo após trecho n=2 94,48
188,96 472,40
577,66
1795,10
2078,54
2456,46
2841,46
3590,21
4487,76
5385,31
Tempo em cada vel. para o trecho n=3 0,00 0,00 0,00 4,29 0,00 0,00 0,00 5,00 0,00 0,00 0,00
Deslocamento após o trecho n=3
1234,37 Ton
Consumo no trecho n=3
16682,99
Gallons
Taxa de consumo após trecho n=3 91,73
183,45 458,63
560,83
1742,80
2017,98
2384,88
2758,67
3485,60
4357,00
5228,40
Tempo em cada vel. para o trecho n=4 0,00 0,00 0,00 4,29 0,00 0,00 0,00 5,00 0,00 0,00 0,00
Deslocamento após o trecho n=4
1182,32 Ton
Consumo no trecho n=4
16196,89
Gallons
Taxa de consumo após trecho n=4 89,02
178,03 445,09
544,26
1691,33
1958,38
2314,45
2677,19
3382,65
4228,31
5073,98
Tempo em cada vel. para o trecho n=5 0,00 0,00 0,00 4,29 0,00 0,00 0,00 5,00 0,00 0,00 0,00
Deslocamento após o trecho n=5
1131,81 Ton
Consumo no trecho n=5
15718,51
Gallons
Taxa de consumo após trecho n=5 86,35
172,70 431,76
527,97
1640,68
1899,74
2245,14
2597,03
3281,36
4101,70
4922,05
Tempo em cada vel. para o trecho n=6 0,00 0,00 0,00 4,29 0,00 0,00 0,00 5,00 0,00 0,00 0,00
Deslocamento após o trecho n=6
1082,81 Ton
Consumo no trecho n=6
15247,85
Gallons
Taxa de consumo após trecho n=6 83,73
167,46 418,65
511,94
1590,87
1842,06
2176,98
2518,18
3181,73
3977,17
4772,60
Tempo em cada vel. para o trecho n=7 0,00 0,00 0,00 4,29 0,00 0,00 0,00 5,00 0,00 0,00 0,00
Deslocamento após o trecho n=7
1035,31 Ton
Consumo no trecho n=7
14784,89
Gallons
Taxa de consumo após trecho n=7 81,15
162,30 405,76
496,17
1541,88
1785,34
2109,94
2440,63
3083,76
3854,70
4625,64
Tabela 32 - 4.2.3.5. Tela de resultado final da rota, rota dividida em 7 trechos (N=7).
Resultado Final N=7
Deslocamento Inicial 1400 ton
Deslocamento Final 1035,305 ton
Consumo Total 113465,8 gallons
Diferença Entre a otimização Simples 8,203% gallons
Rota dividida em dez trechos: N=10
Tabela 33 - 4.2.3.6. Tela de entrada de dados para resolução do problema, rota dividida em 10 trechos (N=10).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
125
Consumos (gal/h) 100 200 500 611 190
0 220
0 260
0 3008 380
0 4750 570
0
Vol. De combustivel 15950
0 gallon
s
Vol da reserva 0 gallon
s
Dados da Rota Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida
Discretização (N) 10
Dados dos Trechos
Restrições
Número de Trechos 10
200 >= 200 E1
Distância dos trechos 200 m.n
Taxa de Consumo X Tempo
12360,5
<= 1595
0 E3 e E4
Tempo por trechos 6,5 h
Tempo por velocidade por
trecho 6,5 > 0 E5
Comb. disp por trechos
15950 Gallon
s
Tempo por velocidade por
trecho 6,5 <= 6,5 E2
Tabela 34 - 4.2.3.6. Tela de resultados para cada trecho, na rota dividida em 10 trechos (N=10).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=1
1360,23 Ton
Consumo no trecho n=1
12360,50
Gallons
Taxa de consumo após trecho n=1 98,10
196,19 490,49
599,78
1863,84
2158,14
2550,52
2950,27
3727,69
4659,61
5591,53
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=2
1321,24 Ton
Consumo no trecho n=2
12125,28
Gallons
126
Taxa de consumo após trecho n=2 96,16
192,32 480,79
587,93
1827,01
2115,49
2500,12
2891,97
3654,02
4567,53
5481,03
Tempo em cada vel. para o trecho n=3 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=3
1283,02 Ton
Consumo no trecho n=3
11885,66
Gallons
Taxa de consumo após trecho n=3 94,24
188,48 471,20
576,20
1790,56
2073,28
2450,24
2834,27
3581,13
4476,41
5371,69
Tempo em cada vel. para o trecho n=4 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=4
1245,56 Ton
Consumo no trecho n=4
11648,55
Gallons
Taxa de consumo após trecho n=4 92,34
184,68 461,71
564,59
1754,50
2031,53
2400,90
2777,19
3509,00
4386,25
5263,51
Tempo em cada vel. para o trecho n=5 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=5
1208,85 Ton
Consumo no trecho n=5
11413,95
Gallons
Taxa de consumo após trecho n=5 90,46
180,93 452,32
553,11
1718,83
1990,22
2352,08
2720,72
3437,65
4297,07
5156,48
Tempo em cada vel. para o trecho n=6 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=6
1172,90 Ton
Consumo no trecho n=6
11181,86
Gallons
Taxa de consumo após trecho n=6 88,61
177,21 443,04
541,76
1683,54
1949,36
2303,79
2664,86
3367,07
4208,84
5050,61
Tempo em cada vel. para o trecho n=7 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=7
1137,68 Ton
Consumo no trecho n=7
10952,28
Gallons
Taxa de consumo após trecho n=7 86,77
173,54 433,85
530,53
1648,63
1908,94
2256,02
2609,61
3297,26
4121,58
4945,89
Tempo em cada vel. para o trecho n=8 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=8
1103,19 Ton
Consumo no trecho n=8
10725,21
Gallons
Taxa de consumo após trecho n=8 84,95
169,91 424,77
519,42
1614,11
1868,97
2208,78
2554,97
3228,22
4035,28
4842,33
Tempo em cada vel. para o trecho n=9 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=9
1069,43 Ton
Consumo no trecho n=9
10500,63
Gallons
Taxa de consumo após trecho n=9 83,16
166,31 415,78
508,43
1579,98
1829,44
2162,07
2500,93
3159,95
3949,94
4739,93
Tempo em cada vel. para o trecho n=10 0,00 0,00 0,00 3,00 0,00 0,00 0,00 3,50 0,00 0,00 0,00
Deslocamento após o trecho n=10
1036,38 Ton
Consumo no trecho n=10
10278,57
Gallons
Taxa de consumo após trecho n=10 81,38
162,76 406,90
497,57
1546,22
1790,37
2115,89
2447,51
3092,45
3865,56
4638,67
Tabela 35 - 4.2.3.6. Tela de resultado final da rota, rota dividida em 10 trechos (N=10).
Resultado Final N=10
Deslocamento Inicial 1400 ton
Deslocamento Final 1036,377 ton
Consumo Total 113072,5 gallons
127
Diferença Entre a otimização Simples 8,521% gallons
Rota dividida em quinze trechos: N=15
Tabela 36 - 4.2.3.7. Tela de entrada de dados para resolução do problema, rota dividida em 15 trechos (N=15).
1 1 1 1 1 1 1 1 1 1 1
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200 500 611 190
0 220
0 260
0 3008 380
0 4750 570
0
Vol. De combustivel
159500
gallons
Vol da reserva 0 gallo
ns
Dados da Rota Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida
Discretização (N) 15
Dados dos Trechos
Restrições
Número de Trechos 15
133,3333
>= 133,33
33 E1
Distância dos trechos 133,3333333 m.n
Taxa de Consumo X
Tempo 8240,3
3 <=
10633,33
E3 e E4
Tempo por trechos 4,333333333 h
Tempo por velocidade por
trecho 4,3333
33 > 0 E5
Comb. disp por trechos
10633,33333 Gallo
ns
Tempo por velocidade por
trecho 4,3333
33 <=
4,333333
E2
128
Tabela 37 - 4.2.3.7. Tela de resultados para cada trecho, na rota dividida em 15 trechos (N=15).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=1
1373,49 Ton
Consumo no trecho n=1
8240,33
Gallons
Taxa de consumo após trecho n=1 98,73
197,47 493,67
603,67
1875,93
2172,13
2567,07
2969,41
3751,87
4689,84
5627,80
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=2
1347,31 Ton
Consumo no trecho n=2
8135,96
Gallons
Taxa de consumo após trecho n=2 97,45
194,90 487,25
595,83
1851,57
2143,92
2533,72
2930,84
3703,14
4628,92
5554,70
Tempo em cada vel. para o trecho n=3 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=3
1321,48 Ton
Consumo no trecho n=3
8030,28
Gallons
Taxa de consumo após trecho n=3 96,18
192,35 480,89
588,04
1827,37
2115,90
2500,60
2892,53
3654,73
4568,41
5482,10
Tempo em cada vel. para o trecho n=4 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=4
1295,99 Ton
Consumo no trecho n=4
7925,31
Gallons
Taxa de consumo após trecho n=4 94,91
189,82 474,56
580,31
1803,33
2088,06
2467,71
2854,48
3606,65
4508,32
5409,98
Tempo em cada vel. para o trecho n=5 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=5
1270,83 Ton
Consumo no trecho n=5
7821,06
Gallons
Taxa de consumo após trecho n=5 93,66
187,31 468,28
572,62
1779,45
2060,42
2435,04
2816,69
3558,91
4448,63
5338,36
Tempo em cada vel. para o trecho n=6 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=6
1246,00 Ton
Consumo no trecho n=6
7717,52
Gallons
Taxa de consumo após trecho n=6 92,41
184,82 462,04
564,99
1755,74
2032,97
2402,60
2779,16
3511,49
4389,36
5267,23
Tempo em cada vel. para o trecho n=7 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=7
1221,51 Ton
Consumo no trecho n=7
7614,69
Gallons
Taxa de consumo após trecho n=7 91,17
182,34 455,84
557,42
1732,20
2005,70
2370,38
2741,89
3464,40
4330,50
5196,60
Tempo em cada vel. para o trecho n=8 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=8
1197,34 Ton
Consumo no trecho n=8
7512,58
Gallons
Taxa de consumo após trecho n=8 89,94
179,88 449,69
549,89
1708,82
1978,63
2338,38
2704,88
3417,64
4272,05
5126,46
Tempo em cada vel. para o trecho n=9 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
129
Deslocamento após o trecho n=9
1173,50 Ton
Consumo no trecho n=9
7411,18
Gallons
Taxa de consumo após trecho n=9 88,72
177,43 443,58
542,42
1685,60
1951,75
2306,61
2668,13
3371,21
4214,01
5056,81
Tempo em cada vel. para o trecho n=10 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=10
1149,99 Ton
Consumo no trecho n=10
7310,49
Gallons
Taxa de consumo após trecho n=10 87,50
175,01 437,51
535,00
1662,55
1925,06
2275,07
2631,64
3325,10
4156,38
4987,65
Tempo em cada vel. para o trecho n=11 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=11
1126,79 Ton
Consumo no trecho n=11
7210,51
Gallons
Taxa de consumo após trecho n=11 86,30
172,60 431,49
527,64
1639,66
1898,56
2243,75
2595,41
3279,33
4099,16
4918,99
Tempo em cada vel. para o trecho n=12 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=12
1103,92 Ton
Consumo no trecho n=12
7111,25
Gallons
Taxa de consumo após trecho n=12 85,10
170,20 425,51
520,33
1616,94
1872,25
2212,65
2559,45
3233,88
4042,35
4850,82
Tempo em cada vel. para o trecho n=13 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=13
1081,36 Ton
Consumo no trecho n=13
7012,69
Gallons
Taxa de consumo após trecho n=13 83,91
167,83 419,57
513,07
1594,38
1846,12
2181,78
2523,74
3188,76
3985,95
4783,14
Tempo em cada vel. para o trecho n=14 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=14
1059,12 Ton
Consumo no trecho n=14
6914,85
Gallons
Taxa de consumo após trecho n=14 82,74
165,47 413,68
505,86
1571,99
1820,19
2151,14
2488,29
3143,97
3929,96
4715,96
Tempo em cada vel. para o trecho n=15 0,00 0,00 0,00 2,00 0,00 0,00 0,00 2,33 0,00 0,00 0,00
Deslocamento após o trecho n=15
1037,19 Ton
Consumo no trecho n=15
6817,72
Gallons
Taxa de consumo após trecho n=15 81,57
163,13 407,83
498,71
1549,75
1794,45
2120,72
2453,10
3099,51
3874,39
4649,26
Tabela 38 - 4.2.3.7. Tela de resultado final da rota, rota dividida em 15 trechos (N=15).
Resultado Final N=15
Deslocamento Inicial 1400 ton
Deslocamento Final 1037,189 ton
Consumo Total 112786,4 gallons
Diferença Entre a otimização Simples 8,753% gallons
Rota dividida em vinte trechos: N=20
Tabela 39 - 4.2.3.8. Tela de entrada de dados para resolução do problema, rota dividida em 20 trechos (N=20).
1 1 1 1 1 1 1 1 1 1 1
130
ENTRADA DE DADOS - "INPUTS" Dados da Embarcação
Deslocamento 1400 ton
Velocidades (knots) 5 10 15 20 25 30 35 40 45 50 55
Consumos (gal/h) 100 200 500 611 190
0 220
0 260
0 3008 380
0 4750 570
0
Vol. De combustivel 15950
0 gallon
s
Vol da reserva 0 gallon
s
Dados da Rota Distância total 2000 m.n
Tempo total 65 h
Discretização Escolhida
Discretização (N) 20
Dados dos Trechos
Restrições
Número de Trechos 20 100 >= 100 E1
Distância dos trechos 100 m.n
Taxa de Consumo X
Tempo 6180,24
8 <= 7975
E3 e E4
Tempo por trechos 3,25 h
Tempo por velocidade por
trecho 3,25 > 0 E5
Comb. disp por trechos
7975 Gallon
s
Tempo por velocidade por
trecho 3,25 <= 3,25 E2
Tabela 40 - 4.2.3.8. Tela de resultados para cada trecho, na rota dividida em 20 trechos (N=20).
Resultados para cada Passo
Velocidades 5 10 15 20 25 30 35 40 45 50 55
Taxa de Consumos Inicial 100 200 500 611 1900 2200 2600 3008 3800 4750 5700
Tempo em cada vel. para o trecho n=1 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
131
Deslocamento após o trecho n=1
1380,11 Ton
Consumo no trecho n=1
6180,25
Gallons
Taxa de consumo após trecho n=1 99,05
198,10 495,25
605,61
1881,97
2179,12
2575,32
2978,95
3763,93
4704,91
5645,90
Tempo em cada vel. para o trecho n=2 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=2
1360,42 Ton
Consumo no trecho n=2
6121,59
Gallons
Taxa de consumo após trecho n=2 98,09
196,19 490,46
599,75
1863,76
2158,04
2550,41
2950,14
3727,52
4659,40
5591,28
Tempo em cada vel. para o trecho n=3 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=3
1340,92 Ton
Consumo no trecho n=3
6062,37
Gallons
Taxa de consumo após trecho n=3 97,14
194,28 485,70
593,92
1845,65
2137,07
2525,62
2921,47
3691,29
4614,12
5536,94
Tempo em cada vel. para o trecho n=4 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=4
1321,60 Ton
Consumo no trecho n=4
6003,45
Gallons
Taxa de consumo após trecho n=4 96,19
192,38 480,95
588,12
1827,62
2116,20
2500,96
2892,94
3655,25
4569,06
5482,87
Tempo em cada vel. para o trecho n=5 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=5
1302,48 Ton
Consumo no trecho n=5
5944,83
Gallons
Taxa de consumo após trecho n=5 95,25
190,49 476,23
582,35
1809,69
2095,43
2476,42
2864,55
3619,38
4524,23
5429,07
Tempo em cada vel. para o trecho n=6 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=6
1283,54 Ton
Consumo no trecho n=6
5886,49
Gallons
Taxa de consumo após trecho n=6 94,31
188,62 471,54
576,61
1791,85
2074,77
2452,00
2836,31
3583,70
4479,62
5375,55
Tempo em cada vel. para o trecho n=7 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=7
1264,79 Ton
Consumo no trecho n=7
5828,46
Gallons
Taxa de consumo após trecho n=7 93,37
186,75 466,87
570,90
1774,10
2054,22
2427,71
2808,21
3548,20
4435,24
5322,29
Tempo em cada vel. para o trecho n=8 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=8
1246,22 Ton
Consumo no trecho n=8
5770,72
Gallons
Taxa de consumo após trecho n=8 92,44
184,89 462,22
565,22
1756,44
2033,77
2403,55
2780,26
3512,87
4391,09
5269,31
Tempo em cada vel. para o trecho n=9 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=9
1227,84 Ton
Consumo no trecho n=9
5713,27
Gallons
Taxa de consumo após trecho n=9 91,52
183,04 457,60
559,56
1738,87
2013,42
2379,50
2752,44
3477,73
4347,17
5216,60
Tempo em cada vel. para o trecho n=10 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=10
1209,65 Ton
Consumo no trecho n=10
5656,12
Gallons
Taxa de consumo após trecho n=10 90,60
181,20 453,00
553,94
1721,39
1993,19
2355,58
2724,77
3442,77
4303,47
5164,16
Tempo em cada vel. para o trecho n=11 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
132
Deslocamento após o trecho n=11
1191,63 Ton
Consumo no trecho n=11
5599,26
Gallons
Taxa de consumo após trecho n=11 89,68
179,37 448,42
548,34
1704,00
1973,05
2331,79
2697,25
3408,00
4259,99
5111,99
Tempo em cada vel. para o trecho n=12 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=12
1173,80 Ton
Consumo no trecho n=12
5542,70
Gallons
Taxa de consumo após trecho n=12 88,77
177,55 443,87
542,78
1686,70
1953,02
2308,11
2669,87
3373,40
4216,75
5060,10
Tempo em cada vel. para o trecho n=13 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=13
1156,15 Ton
Consumo no trecho n=13
5486,43
Gallons
Taxa de consumo após trecho n=13 87,87
175,74 439,34
537,24
1669,49
1933,10
2284,57
2642,63
3338,98
4173,73
5008,47
Tempo em cada vel. para o trecho n=14 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=14
1138,68 Ton
Consumo no trecho n=14
5430,46
Gallons
Taxa de consumo após trecho n=14 86,97
173,93 434,84
531,73
1652,37
1913,27
2261,14
2615,53
3304,75
4130,93
4957,12
Tempo em cada vel. para o trecho n=15 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=15
1121,39 Ton
Consumo no trecho n=15
5374,78
Gallons
Taxa de consumo após trecho n=15 86,07
172,14 430,35
526,25
1635,35
1893,56
2237,84
2588,58
3270,69
4088,37
4906,04
Tempo em cada vel. para o trecho n=16 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=16
1104,28 Ton
Consumo no trecho n=16
5319,39
Gallons
Taxa de consumo após trecho n=16 85,18
170,36 425,90
520,80
1618,41
1873,95
2214,67
2561,77
3236,82
4046,02
4855,23
Tempo em cada vel. para o trecho n=17 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=17
1087,34 Ton
Consumo no trecho n=17
5264,30
Gallons
Taxa de consumo após trecho n=17 84,29
168,59 421,46
515,38
1601,56
1854,44
2191,61
2535,11
3203,13
4003,91
4804,69
Tempo em cada vel. para o trecho n=18 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=18
1070,58 Ton
Consumo no trecho n=18
5209,51
Gallons
Taxa de consumo após trecho n=18 83,41
166,82 417,05
509,99
1584,81
1835,04
2168,68
2508,58
3169,62
3962,02
4754,42
Tempo em cada vel. para o trecho n=19 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=19
1054,00 Ton
Consumo no trecho n=19
5155,00
Gallons
Taxa de consumo após trecho n=19 82,53
165,07 412,67
504,62
1568,14
1815,74
2145,88
2482,20
3136,29
3920,36
4704,43
Tempo em cada vel. para o trecho n=20 0,00 0,00 0,00 1,50 0,00 0,00 0,00 1,75 0,00 0,00 0,00
Deslocamento após o trecho n=20
1037,59 Ton Consumo no trecho n=20
5100,79
Gallons
Taxa de consumo após trecho n=20 81,66
163,32 408,31
499,29
1551,57
1796,55
2123,20
2455,97
3103,14
3878,92
4654,70
133
Tabela 41 - 4.2.3.8. Tela de resultado final da rota, rota dividida em 20 trechos (N=20).
Resultado Final N=20
Deslocamento Inicial 1400 ton
Deslocamento Final 1037,589 ton
Consumo Total 112650,2 gallons
Diferença Entre a otimização Simples 8,863% gallons
134
ANEXO 3
• Código em VBA Sub Solver_otimizar()
'
' Solver_otimizar Macro
'
'
Application.ScreenUpdating = False
ThisWorkbook.Sheets(3).Cells(6, 2).Select
Range("B6:L6").Select
Selection.Copy
ThisWorkbook.Sheets(3).Cells(42, 2).Select
Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks _
:=False, Transpose:=False
ThisWorkbook.Sheets(3).Cells(30, 9) = 0
ThisWorkbook.Sheets(3).Cells(31, 9) = 0
ThisWorkbook.Sheets(3).Cells(29, 9) = ThisWorkbook.Sheets(3).Cells(4, 2)
For i = 1 To ThisWorkbook.Sheets(3).Cells(13, 2)
SolverOk SetCell:="$B$24", MaxMinVal:=2, ValueOf:=0, ByChange:="$B$25:$L$25", _
Engine:=2, EngineDesc:="Simplex LP"
SolverSolve UserFinish:=True
Range("B25:L25").Select
Selection.Copy
ThisWorkbook.Sheets(3).Cells(43 + (i - 1) * 3, 2).Select 'Pintar essa celula
Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks _
:=False, Transpose:=False
Selection.Borders(xlDiagonalDown).LineStyle = xlNone
Selection.Borders(xlDiagonalUp).LineStyle = xlNone
With Selection.Borders(xlEdgeLeft)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeTop)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeBottom)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
135
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeRight)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlInsideVertical)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlThin
End With
Selection.Borders(xlInsideHorizontal).LineStyle = xlNone
With Selection.Interior
.Pattern = xlSolid
.PatternColorIndex = xlAutomatic
.Color = 255
.TintAndShade = 0
.PatternTintAndShade = 0
End With
ThisWorkbook.Sheets(3).Cells(43 + (i - 1) * 3, 1) = "Tempo em cada vel. para o trecho n=" & i
'pintar essa celular
ThisWorkbook.Sheets(3).Cells(43 + (i - 1) * 3, 1).Select
Selection.Borders(xlDiagonalDown).LineStyle = xlNone
Selection.Borders(xlDiagonalUp).LineStyle = xlNone
With Selection.Borders(xlEdgeLeft)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeTop)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeBottom)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeRight)
.LineStyle = xlContinuous
.ColorIndex = 0
136
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlInsideVertical)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlThin
End With
Selection.Borders(xlInsideHorizontal).LineStyle = xlNone
With Selection.Interior
.Pattern = xlSolid
.PatternColorIndex = xlAutomatic
.Color = 255
.TintAndShade = 0
.PatternTintAndShade = 0
End With
ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 1) = "Deslocamento após o trecho n=" & i
ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 3) = "Ton"
ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 2) = ThisWorkbook.Sheets(3).Cells(36, 2)
ThisWorkbook.Sheets(3).Cells(45 + (i - 1) * 3, 1) = "Taxa de consumo após trecho n=" & i
'pintar de laranja claro
ThisWorkbook.Sheets(3).Cells(45 + (i - 1) * 3, 1).Select
Selection.Borders(xlDiagonalDown).LineStyle = xlNone
Selection.Borders(xlDiagonalUp).LineStyle = xlNone
With Selection.Borders(xlEdgeLeft)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeTop)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeBottom)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeRight)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
137
End With
With Selection.Borders(xlInsideVertical)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlThin
End With
Selection.Borders(xlInsideHorizontal).LineStyle = xlNone
With Selection.Interior
.Pattern = xlSolid
.PatternColorIndex = xlAutomatic
.Color = 5287936
.TintAndShade = 0
.PatternTintAndShade = 0
End With
Range("B37:L37").Select
Selection.Copy
ThisWorkbook.Sheets(3).Cells(45 + (i - 1) * 3, 2).Select ' Pintar de laranja claro
Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks _
:=False, Transpose:=False
Selection.Borders(xlDiagonalDown).LineStyle = xlNone
Selection.Borders(xlDiagonalUp).LineStyle = xlNone
With Selection.Borders(xlEdgeLeft)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeTop)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeBottom)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlEdgeRight)
.LineStyle = xlContinuous
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlMedium
End With
With Selection.Borders(xlInsideVertical)
.LineStyle = xlContinuous
138
.ColorIndex = 0
.TintAndShade = 0
.Weight = xlThin
End With
Selection.Borders(xlInsideHorizontal).LineStyle = xlNone
With Selection.Interior
.Pattern = xlSolid
.PatternColorIndex = xlAutomatic
.Color = 5287936
.TintAndShade = 0
.PatternTintAndShade = 0
End With
ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 4) = "Consumo no trecho n=" & i
ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 8) = "Gallons"
ThisWorkbook.Sheets(3).Cells(4, 2) = ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 2)
Range("B37:L37").Select
Selection.Copy
ThisWorkbook.Sheets(3).Cells(6, 2).Select ' Pintar de laranja claro
Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks _
:=False, Transpose:=False
ThisWorkbook.Sheets(3).Cells(30, 9) = ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 2)
ThisWorkbook.Sheets(3).Cells(31, 9) = ThisWorkbook.Sheets(3).Cells(31, 9) +
ThisWorkbook.Sheets(3).Cells(44 + (i - 1) * 3, 7)
Next i
Range("B42:L42").Select
Selection.Copy
ThisWorkbook.Sheets(3).Cells(6, 2).Select
Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks _
:=False, Transpose:=False
ThisWorkbook.Sheets(3).Cells(4, 2) = ThisWorkbook.Sheets(3).Cells(29, 9)
End Sub