Method: shipping.designShippingNetwork

Resolve o problema de design e programação da rede de transporte marítimo (LSNDSP, na sigla em inglês) do DesignShippingNetworkRequest fornecido.

O LSNDSP é um problema complexo de otimização que busca encontrar o projeto e a programação ideais de uma rede de transporte marítimo. O objetivo é minimizar o custo total de operação da rede e, ao mesmo tempo, atender o máximo possível da demanda de carga entre as portas.

O LSNDSP pode ser dividido em dois subproblemas principais: design de rede e programação. O subproblema do projeto da rede determina o conjunto de portas a serem atendidas pela rede, o número de embarcações a serem implantadas em cada rota e as rotas que as embarcações vão seguir. O subproblema de programação determina os horários de navegação dos navios, considerando o tempo necessário para navegar entre os portos, o tempo necessário para carregar e descarregar cargas e a demanda por transporte de cargas entre os portos.

Em palavras simples, o LSNDSP é o problema de decidir quais portas atender, quantas naves usar e como programar as naves para que o custo de operação da rede seja minimizado e, ao mesmo tempo, maximize a receita para atender à demanda de carga. Um subcomponente desafiador do LSNDSP é o roteamento de cargas, que determina quais demandas atender e quais rotas atribuir à carga para maximizar a receita.

Solicitação HTTP

POST https://optimization.googleapis.com/v1/shipping:designShippingNetwork

O URL usa a sintaxe de transcodificação gRPC.

Corpo da solicitação

O corpo da solicitação contém dados com a seguinte estrutura:

Representação JSON 
{
  "requestId": string,
  "solverParameters": {
    object (SolverParameters)
  },
  "ports": [
    {
      object (Port)
    }
  ],
  "legCandidates": [
    {
      object (LegCandidate)
    }
  ],
  "vesselClasses": [
    {
      object (VesselClass)
    }
  ],
  "commodityDemands": [
    {
      object (CommodityDemand)
    }
  ],
  "vesselServices": [
    {
      object (VesselService)
    }
  ]
}
Campos
requestId

string

ID do problema ou da solicitação.
solverParameters

object (SolverParameters)

Parâmetros para o solucionador.
ports[]

object (Port)

Lista de possíveis portas a serem chamadas nos serviços da embarcação. A solicitação só pode conter os IDs de porta que estão nessa lista.
legCandidates[]

object (LegCandidate)

Lista de possíveis candidatos para o trecho a ser adicionado aos serviços de embarcações. A solicitação só pode conter os IDs de candidatos do trecho que estão nessa lista.
vesselClasses[]

object (VesselClass)

Lista de classes de embarcações para realizar serviços. Todos os embarcações da mesma classe são completamente intercambiáveis. A solicitação só pode conter os IDs de classe de embarcação que estão nessa lista.
commodityDemands[]

object (CommodityDemand)

Lista de demandas em potencial de commodities (ou seja, contêineres) a serem atendidas pelos serviços de embarcações.
vesselServices[]

object (VesselService)

Uma rede de serviços de embarcações válidos (normalmente, o estado atual da rede) pode ser fornecida para ser usada como ponto de partida para a otimização.

Corpo da resposta

A resposta mantém a solução para a instância do LSNDSP transmitida na solicitação. Ele contém uma rede válida de serviços de embarcação e caminhos de demanda de commodities. A demanda total de mercadorias que passa por cada trecho não pode exceder a capacidade da classe de embarcação que atende a esse trecho. Não ter serviços de embarcações sem demanda atendida é sempre uma solução viável para o problema de design e programação da rede de transporte marítimo.

Se bem-sucedido, o corpo da resposta incluirá dados com a estrutura a seguir:

Representação JSON 
{
  "requestId": string,
  "vesselServices": [
    {
      object (VesselService)
    }
  ],
  "commodityDemandPaths": [
    {
      object (CommodityDemandPath)
    }
  ]
}
Campos
requestId

string

O ID da solicitação à qual esta resposta está associada.
vesselServices[]

object (VesselService)

Rede de serviços de embarcações. O número total de embarcações usadas não pode exceder o número disponível de cada classe.
commodityDemandPaths[]

object (CommodityDemandPath)

Lista de todos os caminhos de demanda de commodities por meio dos quais a demanda positiva de commodities é enviada. Alguns IDs de demanda de commodities podem não ser incluídos se nenhuma demanda for enviada. Uma demanda de commodities também pode ser parcialmente atendida. Para cada demanda de commodities, a quantidade total atendida não pode ser maior que a total. Por fim, commodityDemandPaths dependem de vesselServices (consulte a definição de CommodityDemandPath).

SolverParameters

Parâmetros que controlam uma única solução do LSNDSP.

Representação JSON 
{
  "timeLimit": string
}
Campos
timeLimit

string (Duration format)

O tempo máximo que o solucionador deve gastar no problema. Esse valor não é um limite fixo e não considera a sobrecarga de comunicação. A latência esperada para resolver o problema pode exceder um pouco esse valor.

Duração em segundos com até nove dígitos fracionários, terminando em "s". Exemplo: "3.5s".

Porta

Por exemplo: porta um ou todos os terminais de uma porta.

Representação JSON 
{
  "id": string,
  "minimumPortStayDuration": {
    object (Duration)
  },
  "minimumTransshipmentDuration": {
    object (Duration)
  },
  "transshipmentCost": number,
  "vesselClassCosts": {
    string: {
      object (VesselCost)
    },
    ...
  }
}
Campos
id

string

ID exclusivo atribuído a esta porta.
minimumPortStayDuration

object (Duration)

Duração mínima da estadia para uma chamada de portabilidade. A maioria dos estudos presume uma constante, porque as portas normalmente atribuem mais guindastes a embarcações maiores com um alto número de movimentos, já que ocupam mais espaço.
minimumTransshipmentDuration

object (Duration)

Duração mínima de um transporte em uma determinada porta, incluindo o tempo para descarregar um contêiner e recarregá-lo em outra embarcação.
transshipmentCost

number

Custo de transferência de um contêiner. Geralmente, esse valor será menor do que a soma das cargas e descargas, porque o transporte não exige papel alfandegário no porto.
vesselClassCosts

map (key: string, value: object (VesselCost))

Custos incorridos ao chamar essa porta, mapeados por ID da classe da embarcação. Uma classe de embarcação só pode chamar essa porta se tiver uma entrada neste mapa.

Um objeto com uma lista de pares "key": value. Exemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

Duração

A duração (estadia/transporte, transporte público de demanda) é definida com granularidade por hora.

Representação JSON 
{
  "hours": string
}
Campos
hours

string (int64 format)

Número de horas definindo a duração.

VesselCost

O custo do navio para fazer chamadas e permanecer nesse porto é definido como uma função linear da duração da estadia (fixedCost + hourlyCost * horas).

Representação JSON 
{
  "fixedCost": number,
  "hourlyCost": number
}
Campos
fixedCost

number

Custo fixo para chamar essa porta.
hourlyCost

number

Custo por hora para ficar neste porto.

LegCandidate

Candidato ao trecho de serviço de embarcação. Pode haver vários candidatos de trecho entre as mesmas duas portas, por exemplo, que representam diferentes rotas oceânicas e/ou velocidades de embarcações.

Representação JSON 
{
  "id": string,
  "departurePortId": string,
  "arrivalPortId": string,
  "duration": {
    object (Duration)
  },
  "vesselClassCosts": {
    string: number,
    ...
  }
}
Campos
id

string

ID exclusivo atribuído a este candidato de trecho.
departurePortId

string

ID da porta de partida.
arrivalPortId

string

ID da porta de chegada.
duration

object (Duration)

Duração do trecho.
vesselClassCosts

map (key: string, value: number)

Custo para atribuir esse candidato de trecho a uma determinada classe de embarcação. Isso pode incluir o custo operacional da embarcação, o custo do bunker, o custo do fretamento. Uma classe de embarcações só pode velejar por esse candidato se houver uma entrada nesse mapa.

Um objeto com uma lista de pares "key": value. Exemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

VesselClass

Classe de embarcações, ou seja, um grupo de embarcações que compartilham as mesmas propriedades. Não há como diferenciar dois recipientes da mesma classe.

Representação JSON 
{
  "id": string,
  "containerCapacity": string,
  "vesselCount": string
}
Campos
id

string

ID exclusivo atribuído a essa classe de embarcação.
containerCapacity

string (int64 format)

Capacidade da classe do embarcação (em contêineres).
vesselCount

string (int64 format)

Número de embarcações nessa classe.

CommodityDemand

Demanda de commodities, ou seja, uma demanda potencial a ser atendida por um remetente.

Representação JSON 
{
  "id": string,
  "originPortId": string,
  "destinationPortId": string,
  "containerCount": string,
  "freightRate": number,
  "maximumTransitDuration": {
    object (Duration)
  }
}
Campos
id

string

ID exclusivo atribuído a essa demanda de commodities.
originPortId

string

ID da porta de origem.
destinationPortId

string

ID da porta de destino.
containerCount

string (int64 format)

Número máximo de contêineres a serem atendidos.
freightRate

number

Taxa de frete por contêiner (o que pode incluir uma penalidade por demanda não atendida). Deve remover o custo de carregamento e descarregamento por contêiner na origem e no destino.
maximumTransitDuration

object (Duration)

Duração máxima em trânsito (se definida, deve ser estritamente positiva). O tempo em trânsito é definido desde o momento em que o primeiro navio que atende a essa demanda sai da porta de origem até o momento em que o último que atende a essa demanda chega ao porto de destino.

VesselService

Serviço de embarcações que pode ser usado para atender às demandas de commodities. IMPORTANTE: supondo que os serviços tenham uma frequência semanal, e os tempos de permanência de porta não podem exceder uma semana. Considere a seguinte sequência de trechos de serviço da embarcação: vesselServiceLegs { legCandidateId: "0->1" originDepartureTime {} destinationArrivalTime { day: 3 hourOfDay: 12 } } vesselServiceLegs { legCandidateId: "1->0" originDepartureTime { day: 4 } destinationArrivalTime { day: 7 hourOfDay: 12 } } Esses trechos definem uma linha de serviço de uma semana passando por duas portas com um tempo de permanência de 12 horas.

Representação JSON 
{
  "vesselClassId": string,
  "vesselServiceLegs": [
    {
      object (VesselServiceLeg)
    }
  ]
}
Campos
vesselClassId

string

ID da classe de embarcação que executa o serviço.
vesselServiceLegs[]

object (VesselServiceLeg)

Para um serviço de embarcação válido, as seguintes propriedades são válidas: 1. Ele não pode ficar em branco. 2. Pernas consecutivas' "destinationPortId" e "originPortId" precisam ser correspondentes (inclusive o último e o primeiro trecho).

VesselServiceLeg

Um único trecho de uma embarcação.

Representação JSON 
{
  "legCandidateId": string,
  "originDepartureTime": {
    object (ScheduleTime)
  },
  "destinationArrivalTime": {
    object (ScheduleTime)
  }
}
Campos
legCandidateId

string

ID de candidato do trecho atribuído.
originDepartureTime

object (ScheduleTime)

Horário de partida na porta de origem de acordo com a programação semanal.
destinationArrivalTime

object (ScheduleTime)

Hora de chegada na porta de destino de acordo com a programação semanal.

ScheduleTime

Um horário programado (embarcações/partida/chegadas de demanda) é definido com uma frequência semanal em uma determinada hora.

Representação JSON 
{
  "day": string,
  "hourOfDay": integer
}
Campos
day

string (int64 format)

Dia na programação. O dia 0 é o primeiro dia possível.
hourOfDay

integer

A hora do dia do horário programado precisa ser um número inteiro entre 0 e 23.

CommodityDemandPath

Os diferentes serviços e portas que uma fração de uma determinada demanda de commodities está tomando. Os índices usados abaixo são baseados na ordem dos serviços de embarcações na resposta e na ordem dos trechos de serviço em serviços individuais.

Representação JSON 
{
  "commodityDemandId": string,
  "containerCount": string,
  "vesselServiceLegIds": [
    {
      object (VesselServiceLegId)
    }
  ]
}
Campos
commodityDemandId

string

ID de demanda de commodities atendido.
containerCount

string (int64 format)

Número de contêineres passando por este caminho. Para cada demanda de commodities, a quantidade total atendida não pode ser maior que a total.
vesselServiceLegIds[]

object (VesselServiceLegId)

Lista de IDs de trechos de serviço da embarcação percorridos por esse caminho. Para um caminho válido de demanda de commodities, as seguintes propriedades são mantidas: 1. O departurePortId do primeiro trecho precisa corresponder ao originPortId da demanda de commodity. 2. O destinationPortId do último trecho precisa corresponder ao destinationPortId da demanda comodity. 3. Pernas consecutivas' arrivalPortId e departurePortId precisam ser correspondentes. 4. Se fornecido para essa demanda de mercadorias, o tempo máximo em trânsito precisa ser maior ou igual à duração total do caminho.

VesselServiceLegId

Trecho de serviço de embarcação única usado em um caminho de demanda de commodities. Por exemplo, considere que há dois serviços de embarcações. O primeiro é composto por três patas (indexadas 0, 1 e 2) e a segunda (indexada por 0 e 1). Além disso, o primeiro trecho do primeiro serviço chega à porta de partida do segundo trecho do segundo serviço. Um caminho comum que consiste nos três IDs de trecho de serviço da embarcação a seguir: {vesselServiceIndex: 0, vesselServiceLegIndex: 2} {vesselServiceIndex: 0, vesselServiceLegIndex: 0} {vesselServiceIndex: 1, vesselServiceLegIndex: 1} significa que os contêineres fazem dois trechos consecutivos do primeiro navio, e cada serviço é um transship1.

Representação JSON 
{
  "vesselServiceIndex": integer,
  "vesselServiceLegIndex": integer
}
Campos
vesselServiceIndex

integer

Índice do serviço de embarcações.
vesselServiceLegIndex

integer

Índice do trecho do serviço de embarcações indexado por vesselServiceIndex.