ShipmentModel

Um modelo de frete contém um conjunto de fretes que precisam ser realizados por um conjunto de veículos, minimizando o custo geral, que é a soma de:

  • o custo de roteamento dos veículos (soma do custo por tempo total, custo por tempo de viagem e custo fixo em todos os veículos).
  • as penalidades de envio não realizado.
  • o custo da duração global dos fretes
Representação JSON
{
  "shipments": [
    {
      object (Shipment)
    }
  ],
  "vehicles": [
    {
      object (Vehicle)
    }
  ],
  "objectives": [
    {
      object (Objective)
    }
  ],
  "globalStartTime": string,
  "globalEndTime": string,
  "globalDurationCostPerHour": number,
  "durationDistanceMatrices": [
    {
      object (DurationDistanceMatrix)
    }
  ],
  "durationDistanceMatrixSrcTags": [
    string
  ],
  "durationDistanceMatrixDstTags": [
    string
  ],
  "transitionAttributes": [
    {
      object (TransitionAttributes)
    }
  ],
  "shipmentTypeIncompatibilities": [
    {
      object (ShipmentTypeIncompatibility)
    }
  ],
  "shipmentTypeRequirements": [
    {
      object (ShipmentTypeRequirement)
    }
  ],
  "precedenceRules": [
    {
      object (PrecedenceRule)
    }
  ],
  "maxActiveVehicles": integer
}
Campos
shipments[]

object (Shipment)

Conjunto de envios que precisam ser realizados no modelo.

vehicles[]

object (Vehicle)

Conjunto de veículos que podem ser usados para realizar visitas.

objectives[]

object (Objective)

O conjunto de objetivos para esse modelo, que vamos transformar em custos. Se não estiver vazio, o modelo de entrada não poderá ter custo. Para receber a solicitação modificada, use solvingMode = TRANSFORM_AND_RETURN_REQUEST. Nesse caso, a solicitação não será resolvida. Consulte a documentação correspondente.

Experimental: consulte https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request para mais detalhes.

globalStartTime

string (Timestamp format)

Horário de início e término global do modelo: nenhum horário fora desse intervalo pode ser considerado válido.

O período do modelo precisa ser inferior a um ano, ou seja, globalEndTime e globalStartTime precisam estar dentro de 31.536. 000 segundos um do outro.

Ao usar campos cost_per_*hour, talvez seja interessante definir essa janela para um intervalo menor e aumentar a performance. Por exemplo, se você modelar um único dia, defina os limites globais de tempo para esse dia. Se não for definido, 00:00:00 UTC, 1º de janeiro de 1970 (ou seja, segundos: 0, nanos: 0) será usado como padrão.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

globalEndTime

string (Timestamp format)

Se não for definido, será usado 00:00:00 UTC, 1º de janeiro de 1971 (ou seja, segundos: 31536000, nanos: 0) como padrão.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

globalDurationCostPerHour

number

A "duração global" do plano geral é a diferença entre o horário de início efetivo mais cedo e o horário de término efetivo mais tarde de todos os veículos. Os usuários podem atribuir um custo por hora a essa quantidade para tentar otimizar a conclusão mais rápida do trabalho, por exemplo. Esse custo precisa estar na mesma unidade que Shipment.penalty_cost.

durationDistanceMatrices[]

object (DurationDistanceMatrix)

Especifica as matrizes de duração e distância usadas no modelo. Se esse campo estiver vazio, o Google Maps ou as distâncias geodésicas serão usados, dependendo do valor do campo useGeodesicDistances. Se não estiver vazio, useGeodesicDistances não poderá ser verdadeiro, e nem durationDistanceMatrixSrcTags nem durationDistanceMatrixDstTags poderão estar vazios.

Exemplos de uso:

  • Há dois locais: locA e locB.
  • Um veículo que começa e termina o trajeto em locA.
  • 1 solicitação de visita para retirada em locB.
model {
  vehicles { startTags: "locA"  endTags: "locA" }
  shipments { pickups { tags: "locB" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixDstTags: "locA"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrices {
    rows {  # from: locA
      durations { seconds: 0 }   meters: 0    # to: locA
      durations { seconds: 100 } meters: 1000 # to: locB
    }
    rows {  # from: locB
      durations { seconds: 102 } meters: 990 # to: locA
      durations { seconds: 0 }   meters: 0   # to: locB
    }
  }
}
  • Há três locais: locA, locB e locC.
  • Um veículo que começa o trajeto em locA e termina em locB, usando a matriz "fast".
  • Um veículo que começa e termina o trajeto em locB, usando a matriz "slow".
  • Um veículo que começa e termina o trajeto em locB, usando a matriz "fast".
  • 1 solicitação de visita para retirada em locC.
model {
  vehicles { startTags: "locA" endTags: "locB" startTags: "fast" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "slow" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "fast" }
  shipments { pickups { tags: "locC" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixSrcTags: "locC"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrixDstTags: "locC"
  durationDistanceMatrices {
    vehicleStartTag: "fast"
    rows {  # from: locA
      durations { seconds: 1000 } meters: 2000 # to: locB
      durations { seconds: 600 }  meters: 1000 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }   meters: 0    # to: locB
      durations { seconds: 700 } meters: 1200 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 702 } meters: 1190 # to: locB
      durations { seconds: 0 }   meters: 0    # to: locC
    }
  }
  durationDistanceMatrices {
    vehicleStartTag: "slow"
    rows {  # from: locA
      durations { seconds: 1800 } meters: 2001 # to: locB
      durations { seconds: 900 }  meters: 1002 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }    meters: 0    # to: locB
      durations { seconds: 1000 } meters: 1202 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 1001 } meters: 1195 # to: locB
      durations { seconds: 0 }    meters: 0    # to: locC
    }
  }
}
durationDistanceMatrixSrcTags[]

string

Tags que definem as fontes das matrizes de duração e distância. durationDistanceMatrices(i).rows(j) define durações e distâncias de visitas com a tag durationDistanceMatrixSrcTags(j) para outras visitas na matriz i.

As tags correspondem a VisitRequest.tags ou Vehicle.start_tags. Um determinado VisitRequest ou Vehicle precisa corresponder exatamente a uma tag neste campo. As tags de origem, destino e matriz de um Vehicle podem ser iguais, assim como as tags de origem e destino de um VisitRequest. Todas as tags precisam ser diferentes e não podem ser strings vazias. Se esse campo não estiver vazio, durationDistanceMatrices também não poderá estar.

durationDistanceMatrixDstTags[]

string

Tags que definem os destinos das matrizes de duração e distância; durationDistanceMatrices(i).rows(j).durations(k) (respectivamente. durationDistanceMatrices(i).rows(j).meters(k)) define a duração (ou a distância) da viagem de visitas com a tag durationDistanceMatrixSrcTags(j) para visitas com a tag durationDistanceMatrixDstTags(k) na matriz i.

As tags correspondem a VisitRequest.tags ou Vehicle.start_tags. Um determinado VisitRequest ou Vehicle precisa corresponder exatamente a uma tag neste campo. As tags de origem, destino e matriz de um Vehicle podem ser iguais, assim como as tags de origem e destino de um VisitRequest. Todas as tags precisam ser diferentes e não podem ser strings vazias. Se esse campo não estiver vazio, durationDistanceMatrices também não poderá estar.

transitionAttributes[]

object (TransitionAttributes)

Atributos de transição adicionados ao modelo.

shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

Conjuntos de shipment_types incompatíveis (consulte ShipmentTypeIncompatibility).

shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

Conjuntos de requisitos shipmentType (consulte ShipmentTypeRequirement).

precedenceRules[]

object (PrecedenceRule)

Conjunto de regras de precedência que precisam ser aplicadas no modelo.

IMPORTANTE: o uso de regras de precedência limita o tamanho do problema que pode ser otimizado. As solicitações que usam regras de precedência e incluem muitos envios podem ser rejeitadas.

maxActiveVehicles

integer

Restringe o número máximo de veículos ativos. Um veículo está ativo se a rota dele realizar pelo menos uma entrega. Isso pode ser usado para limitar o número de rotas quando há menos motoristas do que veículos e a frota é heterogênea. Em seguida, a otimização seleciona o melhor subconjunto de veículos para usar. Precisa ser estritamente positivo.

Envio

O envio de um único item, de uma das retiradas para uma das entregas. Para que o envio seja considerado realizado, um veículo exclusivo precisa visitar um dos locais de coleta (e diminuir as capacidades disponíveis de acordo) e, em seguida, visitar um dos locais de entrega (e, portanto, aumentar as capacidades disponíveis de acordo).

Representação JSON
{
  "displayName": string,
  "pickups": [
    {
      object (VisitRequest)
    }
  ],
  "deliveries": [
    {
      object (VisitRequest)
    }
  ],
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "allowedVehicleIndices": [
    integer
  ],
  "costsPerVehicle": [
    number
  ],
  "costsPerVehicleIndices": [
    integer
  ],
  "pickupToDeliveryAbsoluteDetourLimit": string,
  "pickupToDeliveryTimeLimit": string,
  "shipmentType": string,
  "label": string,
  "ignore": boolean,
  "penaltyCost": number,
  "pickupToDeliveryRelativeDetourLimit": number
}
Campos
displayName

string

O nome de exibição da remessa definido pelo usuário. Ele pode ter até 63 caracteres e usar caracteres UTF-8.

pickups[]

object (VisitRequest)

Conjunto de alternativas de retirada associadas ao envio. Se não for especificado, o veículo só precisará visitar um local correspondente às entregas.

deliveries[]

object (VisitRequest)

Conjunto de alternativas de entrega associadas ao envio. Se não for especificado, o veículo só precisará visitar um local correspondente às coletas.

loadDemands

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

Demandas de carga do frete (por exemplo, peso, volume, número de paletes etc.). As chaves no mapa precisam ser identificadores que descrevem o tipo da carga correspondente, idealmente incluindo também as unidades. Por exemplo: "weight_kg", "volume_gallons", "pallet_count&quot etc. Se uma determinada chave não aparecer no mapa, a carga correspondente será considerada nula.

allowedVehicleIndices[]

integer

O conjunto de veículos que podem fazer essa entrega. Se estiver vazio, todos os veículos poderão realizar a ação. Os veículos são fornecidos pelo índice deles na lista vehicles do ShipmentModel.

costsPerVehicle[]

number

Especifica o custo incorrido quando esta remessa é entregue por cada veículo. Se especificado, ele precisa ter UMA das seguintes opções:

  • o mesmo número de elementos que costsPerVehicleIndices. costsPerVehicle[i] corresponde ao veículo costsPerVehicleIndices[i] do modelo.
  • o mesmo número de elementos que há veículos no modelo. O elemento i-ésimo corresponde ao veículo nº i do modelo.

Esses custos precisam estar na mesma unidade que penaltyCost e não podem ser negativos. Deixe esse campo em branco se não houver custos desse tipo.

costsPerVehicleIndices[]

integer

Índices dos veículos a que costsPerVehicle se aplica. Se não estiver vazio, precisará ter o mesmo número de elementos que costsPerVehicle. Um índice de veículo não pode ser especificado mais de uma vez. Se um veículo for excluído de costsPerVehicleIndices, o custo dele será zero.

pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

Especifica o tempo máximo absoluto de desvio em comparação com o caminho mais curto da coleta até a entrega. Se especificado, ele precisa ser não negativo, e o frete precisa conter pelo menos uma coleta e uma entrega.

Por exemplo, seja t o menor tempo necessário para ir da alternativa de retirada selecionada diretamente para a alternativa de entrega selecionada. Em seguida, a configuração pickupToDeliveryAbsoluteDetourLimit impõe:

startTime(delivery) - startTime(pickup) <=
t + pickupToDeliveryAbsoluteDetourLimit

Se os limites relativos e absolutos forem especificados no mesmo frete, o limite mais restritivo será usado para cada par possível de retirada/entrega. Desde outubro de 2017, os desvios só são aceitos quando as durações das viagens não dependem de veículos.

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

pickupToDeliveryTimeLimit

string (Duration format)

Especifica a duração máxima desde o início da coleta até o início da entrega de uma remessa. Se especificado, ele precisa ser não negativo, e o frete precisa conter pelo menos uma coleta e uma entrega. Isso não depende de quais alternativas são selecionadas para retirada e entrega, nem da velocidade do veículo. Isso pode ser especificado junto com as restrições máximas de desvio: a solução vai respeitar as duas especificações.

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

shipmentType

string

String não vazia que especifica um "tipo" para este frete. Esse recurso pode ser usado para definir incompatibilidades ou requisitos entre shipment_types (consulte shipmentTypeIncompatibilities e shipmentTypeRequirements em ShipmentModel).

Diferente de visitTypes, que é especificado para uma única visita: todas as retiradas/entregas pertencentes ao mesmo envio compartilham o mesmo shipmentType.

label

string

Especifica um rótulo para este envio. Esse rótulo é informado na resposta no shipmentLabel do ShipmentRoute.Visit correspondente.

ignore

boolean

Se for verdadeiro, ignore este envio, mas não aplique um penaltyCost.

Ignorar um envio resulta em um erro de validação quando há shipmentTypeRequirements no modelo.

É permitido ignorar uma entrega feita em injectedFirstSolutionRoutes ou injectedSolutionConstraint. O solucionador remove as visitas de coleta/entrega relacionadas da rota em execução. precedenceRules que fazem referência a envios ignorados também serão ignorados.

penaltyCost

number

Se o envio não for concluído, essa penalidade será adicionada ao custo geral dos trajetos. Uma remessa é considerada concluída se uma das alternativas de retirada e entrega for visitada. O custo pode ser expresso na mesma unidade usada para todos os outros campos relacionados a custos no modelo e precisa ser positivo.

IMPORTANTE: se essa penalidade não for especificada, ela será considerada infinita, ou seja, o envio precisa ser concluído.

pickupToDeliveryRelativeDetourLimit

number

Especifica o tempo máximo de desvio relativo em comparação com o caminho mais curto da coleta até a entrega. Se especificado, ele precisa ser não negativo, e o frete precisa conter pelo menos uma coleta e uma entrega.

Por exemplo, seja t o menor tempo necessário para ir da alternativa de retirada selecionada diretamente para a alternativa de entrega selecionada. Em seguida, a configuração pickupToDeliveryRelativeDetourLimit impõe:

startTime(delivery) - startTime(pickup) <=
std::ceil(t * (1.0 + pickupToDeliveryRelativeDetourLimit))

Se os limites relativos e absolutos forem especificados no mesmo frete, o limite mais restritivo será usado para cada par possível de retirada/entrega. Desde outubro de 2017, os desvios só são aceitos quando as durações das viagens não dependem de veículos.

VisitRequest

Solicitação de uma visita que pode ser feita por um veículo: ela tem uma geolocalização (ou duas, consulte abaixo), horários de abertura e fechamento representados por intervalos de tempo e uma duração de serviço (tempo gasto pelo veículo depois que ele chega para retirar ou entregar mercadorias).

Representação JSON
{
  "arrivalLocation": {
    object (LatLng)
  },
  "arrivalWaypoint": {
    object (Waypoint)
  },
  "departureLocation": {
    object (LatLng)
  },
  "departureWaypoint": {
    object (Waypoint)
  },
  "tags": [
    string
  ],
  "timeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "duration": string,
  "cost": number,
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "visitTypes": [
    string
  ],
  "label": string,
  "avoidUTurns": boolean
}
Campos
arrivalLocation

object (LatLng)

A geolocalização em que o veículo chega ao realizar esse VisitRequest. Se o modelo de frete tiver matrizes de distância de duração, arrivalLocation não poderá ser especificado.

arrivalWaypoint

object (Waypoint)

O ponto de parada em que o veículo chega ao realizar este VisitRequest. Se o modelo de frete tiver matrizes de distância de duração, arrivalWaypoint não poderá ser especificado.

departureLocation

object (LatLng)

A geolocalização de onde o veículo sai após concluir este VisitRequest. Pode ser omitido se for igual a arrivalLocation. Se o modelo de frete tiver matrizes de distância de duração, departureLocation não poderá ser especificado.

departureWaypoint

object (Waypoint)

O ponto de parada em que o veículo sai após concluir este VisitRequest. Pode ser omitido se for igual a arrivalWaypoint. Se o modelo de frete tiver matrizes de distância de duração, departureWaypoint não poderá ser especificado.

tags[]

string

Especifica tags anexadas à solicitação de visita. Não é permitido usar strings vazias ou duplicadas.

timeWindows[]

object (TimeWindow)

Intervalos de tempo que restringem o horário de chegada em uma visita. Um veículo pode sair fora da janela de tempo de chegada. Ou seja, o horário de chegada e a duração não precisam estar dentro de uma janela de tempo. Isso pode resultar em tempo de espera se o veículo chegar antes de TimeWindow.start_time.

A ausência de TimeWindow significa que o veículo pode fazer essa visita a qualquer momento.

As janelas de tempo não podem se sobrepor ou ser adjacentes umas às outras e precisam estar em ordem crescente.

costPerHourAfterSoftEndTime e softEndTime só podem ser definidos se houver um único período.

duration

string (Duration format)

Duração da visita, ou seja, tempo gasto pelo veículo entre a chegada e a partida (a ser adicionado ao possível tempo de espera; consulte timeWindows).

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

cost

number

Custo para atender a essa solicitação de visita em um trajeto de veículo. Isso pode ser usado para pagar custos diferentes para cada retirada ou entrega alternativa de uma remessa. Esse custo precisa estar na mesma unidade que Shipment.penalty_cost e não pode ser negativo.

loadDemands

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

Carrega as demandas desta solicitação de visita. É igual ao campo Shipment.load_demands, mas se aplica apenas a este VisitRequest, em vez de todo o Shipment. As demandas listadas aqui são adicionadas às demandas listadas em Shipment.load_demands.

visitTypes[]

string

Especifica os tipos de visita. Isso pode ser usado para alocar o tempo extra necessário para um veículo concluir essa visita (consulte Vehicle.extra_visit_duration_for_visit_type).

Um tipo só pode aparecer uma vez.

label

string

Especifica um rótulo para este VisitRequest. Esse rótulo é informado na resposta como visitLabel no ShipmentRoute.Visit correspondente.

avoidUTurns

boolean

Especifica se retornos devem ser evitados em trajetos de carro nesse local. A prevenção de retornos é o melhor esforço possível, mas não é garantida. Este é um recurso experimental, e o comportamento dele está sujeito a mudanças.

Experimental: consulte https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request para mais detalhes.

LatLng

Um objeto que representa um par de latitude/longitude. Ele é expresso como um par de valores duplos para representar graus de latitude e longitude. A menos que especificado de outra forma, esse objeto precisa seguir o padrão WGS84. Os valores precisam estar dentro de intervalos normalizados.

Representação JSON
{
  "latitude": number,
  "longitude": number
}
Campos
latitude

number

A latitude em graus. Precisa estar no intervalo [-90,0, +90,0].

longitude

number

A longitude em graus. Precisa estar no intervalo [-180,0, +180,0].

Ponto de referência

Encapsula um ponto de parada. Os pontos de referência marcam os locais de chegada e partida de VisitRequests e os locais de início e término de Vehicles.

Representação JSON
{
  "sideOfRoad": boolean,
  "vehicleStopover": boolean,

  // Union field location_type can be only one of the following:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of list of possible types for union field location_type.
}
Campos
sideOfRoad

boolean

Opcional. Indica que o local deste waypoint tem uma preferência para que o veículo pare em um determinado lado da via. Quando você define esse valor, o trajeto passa pelo local para que o veículo possa parar na lateral da via em que o local está mais próximo do centro da via. Essa opção não funciona para o modo de viagem "A PÉ".

vehicleStopover

boolean

Indica que o waypoint é destinado a veículos para parar, com a intenção de pegar ou deixar alguém. Essa opção funciona apenas para o modo de viagem "CARRO" e quando o "locationType" é "location".

Experimental: o comportamento ou a existência deste campo podem mudar no futuro.

Campo de união location_type. Diferentes maneiras de representar um local. location_type pode ser apenas de um dos tipos a seguir:
location

object (Location)

Um ponto especificado usando coordenadas geográficas, incluindo um título opcional.

placeId

string

O ID do lugar do PDI associado ao ponto de referência.

Ao usar um ID de lugar para especificar o local de chegada ou partida de um VisitRequest, use um ID de lugar específico o suficiente para determinar um local LatLng para navegação até o lugar. Por exemplo, um ID de lugar que representa um edifício é adequado, mas um ID de lugar que representa uma rua não é recomendado.

Local

Encapsula um local (um ponto geográfico e um título opcional).

Representação JSON
{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}
Campos
latLng

object (LatLng)

As coordenadas geográficas do ponto de parada.

heading

integer

A direção da bússola associada à direção do fluxo de tráfego. Esse valor é usado para especificar o lado da via a ser usado para embarque e desembarque. Os valores de direção podem variar de 0 a 360, em que 0 especifica uma direção para o norte, 90 especifica uma direção para o leste e assim por diante.

TimeWindow

As janelas de tempo restringem o horário de um evento, como o horário de chegada em uma visita ou o horário de início e término de um veículo.

Os limites de período fixos, startTime e endTime, impõem o horário mais cedo e mais tarde do evento, de modo que startTime <= event_time <= endTime. O limite inferior da janela de tempo flexível, softStartTime, expressa uma preferência para que o evento aconteça em softStartTime ou depois, incorrendo em um custo proporcional ao tempo antes de softStartTime em que o evento ocorre. O limite superior da janela de tempo flexível, softEndTime, expressa uma preferência para que o evento aconteça em softEndTime ou antes, incorrendo em um custo proporcional ao tempo decorrido após softEndTime. startTime, endTime, softStartTime e softEndTime precisam estar dentro dos limites de tempo globais (consulte ShipmentModel.global_start_time e ShipmentModel.global_end_time) e respeitar:

  0 <= `startTime` <= `endTime` and
  0 <= `startTime` <= `softStartTime` and
  0 <= `softEndTime` <= `endTime`.
Representação JSON
{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}
Campos
startTime

string (Timestamp format)

O horário de início do período rígido. Se não for especificado, será definido como ShipmentModel.global_start_time.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

endTime

string (Timestamp format)

O horário de término do período fixo. Se não for especificado, será definido como ShipmentModel.global_end_time.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

softStartTime

string (Timestamp format)

O horário de início gradual do período.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

softEndTime

string (Timestamp format)

O horário de término flexível do período.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

costPerHourBeforeSoftStartTime

number

Um custo por hora adicionado a outros custos no modelo se o evento ocorrer antes de softStartTime, calculado como:

   max(0, softStartTime - t.seconds)
                          * costPerHourBeforeSoftStartTime / 3600,
t being the time of the event.

Esse custo precisa ser positivo, e o campo só pode ser definido se softStartTime tiver sido definido.

costPerHourAfterSoftEndTime

number

Um custo por hora adicionado a outros custos no modelo se o evento ocorrer após softEndTime, calculado como:

   max(0, t.seconds - softEndTime.seconds)
                    * costPerHourAfterSoftEndTime / 3600,
t being the time of the event.

Esse custo precisa ser positivo, e o campo só pode ser definido se softEndTime tiver sido definido.

Veículo

Modela um veículo em um problema de frete. Resolver um problema de envio vai criar um trajeto começando em startLocation e terminando em endLocation para esse veículo. Um trajeto é uma sequência de visitas (consulte ShipmentRoute).

Representação JSON
{
  "displayName": string,
  "travelMode": enum (TravelMode),
  "routeModifiers": {
    object (RouteModifiers)
  },
  "startLocation": {
    object (LatLng)
  },
  "startWaypoint": {
    object (Waypoint)
  },
  "endLocation": {
    object (LatLng)
  },
  "endWaypoint": {
    object (Waypoint)
  },
  "startTags": [
    string
  ],
  "endTags": [
    string
  ],
  "startTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "endTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "unloadingPolicy": enum (UnloadingPolicy),
  "loadLimits": {
    string: {
      object (LoadLimit)
    },
    ...
  },
  "costPerHour": number,
  "costPerTraveledHour": number,
  "costPerKilometer": number,
  "fixedCost": number,
  "usedIfRouteIsEmpty": boolean,
  "routeDurationLimit": {
    object (DurationLimit)
  },
  "travelDurationLimit": {
    object (DurationLimit)
  },
  "routeDistanceLimit": {
    object (DistanceLimit)
  },
  "extraVisitDurationForVisitType": {
    string: string,
    ...
  },
  "breakRule": {
    object (BreakRule)
  },
  "label": string,
  "ignore": boolean,
  "travelDurationMultiple": number
}
Campos
displayName

string

O nome de exibição do veículo definido pelo usuário. Ele pode ter até 63 caracteres e usar caracteres UTF-8.

travelMode

enum (TravelMode)

O modo de viagem que afeta as vias utilizáveis pelo veículo e a velocidade dele. Consulte também travelDurationMultiple.

routeModifiers

object (RouteModifiers)

Um conjunto de condições a serem satisfeitas que afetam a forma como as rotas são calculadas para o veículo especificado.

startLocation

object (LatLng)

Localização geográfica em que o veículo começa antes de pegar qualquer envio. Se não for especificado, o veículo vai começar na primeira coleta. Se o modelo de frete tiver matrizes de duração e distância, startLocation não poderá ser especificado.

startWaypoint

object (Waypoint)

Ponto de referência que representa um local geográfico onde o veículo começa antes de coletar qualquer entrega. Se nem startWaypoint nem startLocation forem especificados, o veículo vai começar na primeira coleta. Se o modelo de frete tiver matrizes de duração e distância, startWaypoint não poderá ser especificado.

endLocation

object (LatLng)

Localização geográfica em que o veículo termina depois de concluir a última VisitRequest. Se não for especificado, o ShipmentRoute do veículo vai terminar imediatamente quando ele concluir o último VisitRequest. Se o modelo de frete tiver matrizes de duração e distância, endLocation não poderá ser especificado.

endWaypoint

object (Waypoint)

Ponto de parada que representa um local geográfico em que o veículo termina depois de concluir o último VisitRequest. Se nem endWaypoint nem endLocation forem especificados, o ShipmentRoute do veículo vai terminar imediatamente quando concluir o último VisitRequest. Se o modelo de frete tiver matrizes de duração e distância, endWaypoint não poderá ser especificado.

startTags[]

string

Especifica tags anexadas ao início do trajeto do veículo.

Não é permitido usar strings vazias ou duplicadas.

endTags[]

string

Especifica tags anexadas ao final do trajeto do veículo.

Não é permitido usar strings vazias ou duplicadas.

startTimeWindows[]

object (TimeWindow)

Períodos em que o veículo pode sair do local de partida. Eles precisam estar dentro dos limites de tempo globais (consulte os campos ShipmentModel.global_*). Se não for especificado, não haverá limitação além dos limites de tempo globais.

Os períodos pertencentes ao mesmo campo repetido precisam ser disjuntos, ou seja, nenhum período pode se sobrepor ou ser adjacente a outro, e eles precisam estar em ordem cronológica.

costPerHourAfterSoftEndTime e softEndTime só podem ser definidos se houver um único período.

endTimeWindows[]

object (TimeWindow)

Períodos em que o veículo pode chegar ao local de destino. Eles precisam estar dentro dos limites de tempo globais (consulte os campos ShipmentModel.global_*). Se não for especificado, não haverá limitação além dos limites de tempo globais.

Os períodos pertencentes ao mesmo campo repetido precisam ser disjuntos, ou seja, nenhum período pode se sobrepor ou ser adjacente a outro, e eles precisam estar em ordem cronológica.

costPerHourAfterSoftEndTime e softEndTime só podem ser definidos se houver um único período.

unloadingPolicy

enum (UnloadingPolicy)

Política de descarga aplicada ao veículo.

loadLimits

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

Capacidades do veículo (peso, volume, número de paletes, por exemplo). As chaves no mapa são os identificadores do tipo de carga, consistentes com as chaves do campo Shipment.load_demands. Se uma determinada chave estiver ausente desse mapa, a capacidade correspondente será considerada ilimitada.

costPerHour

number

Custos do veículo: todos os custos são somados e precisam estar na mesma unidade de Shipment.penalty_cost.

Custo por hora da rota do veículo. Esse custo é aplicado ao tempo total gasto no trajeto e inclui tempo de viagem, tempo de espera e tempo de visita. Usar costPerHour em vez de apenas costPerTraveledHour pode resultar em latência adicional.

costPerTraveledHour

number

Custo por hora de viagem do trajeto do veículo. Esse custo é aplicado apenas ao tempo de viagem do trajeto (ou seja, o informado em ShipmentRoute.transitions) e exclui o tempo de espera e de visita.

costPerKilometer

number

Custo por quilômetro da rota do veículo. Esse custo é aplicado à distância informada no ShipmentRoute.transitions e não se aplica a nenhuma distância percorrida implicitamente do arrivalLocation ao departureLocation de um único VisitRequest.

fixedCost

number

Custo fixo aplicado se este veículo for usado para lidar com uma remessa.

usedIfRouteIsEmpty

boolean

Esse campo só se aplica a veículos quando a rota deles não atende a nenhuma entrega. Ele indica se o veículo deve ser considerado usado ou não nesse caso.

Se for verdadeiro, o veículo vai do local de início até o de término, mesmo que não atenda a nenhuma entrega, e os custos de tempo e distância resultantes da viagem de início para término serão considerados.

Caso contrário, ele não vai da origem ao destino, e nenhum breakRule ou atraso (de TransitionAttributes) será programado para esse veículo. Nesse caso, o ShipmentRoute do veículo não contém nenhuma informação, exceto o índice e o rótulo do veículo.

routeDurationLimit

object (DurationLimit)

Limite aplicado à duração total do trajeto do veículo. Em um determinado OptimizeToursResponse, a duração do trajeto de um veículo é a diferença entre o vehicleEndTime e o vehicleStartTime.

travelDurationLimit

object (DurationLimit)

Limite aplicado à duração da viagem do trajeto do veículo. Em um determinado OptimizeToursResponse, a duração da viagem do trajeto é a soma de todos os transitions.travel_duration.

routeDistanceLimit

object (DistanceLimit)

Limite aplicado à distância total do trajeto do veículo. Em um determinado OptimizeToursResponse, a distância da rota é a soma de todos os transitions.travel_distance_meters.

extraVisitDurationForVisitType

map (key: string, value: string (Duration format))

Especifica um mapa de strings visitTypes para durações. A duração é o tempo além de VisitRequest.duration a ser tomado nas visitas com o visitTypes especificado. Essa duração extra da visita adiciona custo se costPerHour for especificado. As chaves (ou seja, visitTypes) não podem ser strings vazias.

Se um pedido de visita tiver vários tipos, uma duração será adicionada para cada tipo no mapa.

breakRule

object (BreakRule)

Descreve a programação de pausas a ser aplicada neste veículo. Se estiver vazio, nenhuma pausa será programada para esse veículo.

label

string

Especifica um rótulo para o veículo. Esse rótulo é informado na resposta como o vehicleLabel do ShipmentRoute correspondente.

ignore

boolean

Se for verdadeiro, usedIfRouteIsEmpty precisará ser falso, e o veículo vai permanecer sem uso.

Se um veículo ignorado em injectedFirstSolutionRoutes fizer uma entrega, ela será ignorada na primeira solução, mas poderá ser realizada na resposta.

Se um envio for realizado por um veículo ignorado em injectedSolutionConstraint e qualquer coleta/entrega relacionada for restrita a permanecer no veículo (ou seja, não relaxada para o nível RELAX_ALL_AFTER_THRESHOLD), ela será ignorada na resposta. Se um envio tiver um campo allowedVehicleIndices não vazio e todos os veículos permitidos forem ignorados, ele será ignorado na resposta.

travelDurationMultiple

number

Especifica um fator multiplicativo que pode ser usado para aumentar ou diminuir os tempos de viagem deste veículo. Por exemplo, definir como 2,0 significa que esse veículo é mais lento e tem tempos de viagem que são o dobro dos veículos padrão. Esse múltiplo não afeta as durações das visitas. Isso afeta o custo se costPerHour ou costPerTraveledHour forem especificados. Precisa estar no intervalo [0,001, 1000,0]. Se não for definido, o veículo será padrão, e esse múltiplo será considerado 1,0.

AVISO: os tempos de viagem serão arredondados para o segundo mais próximo depois que esse múltiplo for aplicado, mas antes de realizar qualquer operação numérica. Portanto, um múltiplo pequeno pode resultar em uma perda de precisão.

Consulte também extraVisitDurationForVisitType abaixo.

TravelMode

Meios de transporte que podem ser usados por veículos.

Eles precisam ser um subconjunto dos modos de viagem da API Routes da Plataforma Google Maps. Consulte: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode

Observação: as rotas WALKING estão na versão Beta e podem não ter calçadas ou caminhos para pedestres claros. Você precisa mostrar esse aviso ao usuário para todos os trajetos a pé exibidos no app.

Tipos enumerados
TRAVEL_MODE_UNSPECIFIED Meio de transporte não especificado, equivalente a DRIVING.
DRIVING Meio de transporte correspondente às rotas de carro (carro, etc.).
WALKING Meio de transporte correspondente às rotas a pé.

RouteModifiers

Encapsula um conjunto de condições opcionais a serem satisfeitas ao calcular rotas de veículos. Isso é semelhante a RouteModifiers na API Routes Preferred da Plataforma Google Maps. Consulte: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers.

Representação JSON
{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}
Campos
avoidTolls

boolean

Especifica se é preciso evitar vias com pedágio quando possível. A preferência será dada a trajetos sem pedágios. Válido apenas para modos de viagem motorizados.

avoidHighways

boolean

Especifica se é necessário evitar rodovias quando possível. A preferência será dada a trajetos que não incluem rodovias. Válido apenas para modos de viagem motorizados.

avoidFerries

boolean

Especifica se é necessário evitar balsas quando possível. A preferência será dada a trajetos que não incluem viagens de balsa. Válido apenas para modos de viagem motorizados.

avoidIndoor

boolean

Opcional. Especifica se é preciso evitar a navegação em ambientes internos quando possível. A preferência será dada a rotas que não contêm navegação interna. Aplicável apenas ao modo de viagem WALKING.

UnloadingPolicy

Política sobre como um veículo pode ser descarregado. Aplica-se apenas a remessas com retirada e entrega.

Outros envios podem ocorrer em qualquer lugar da rota, independente de unloadingPolicy.

Tipos enumerados
UNLOADING_POLICY_UNSPECIFIED Política de descarga não especificada. As entregas só podem ocorrer após as respectivas retiradas.
LAST_IN_FIRST_OUT As entregas precisam ocorrer na ordem inversa das retiradas
FIRST_IN_FIRST_OUT As entregas precisam ocorrer na mesma ordem das retiradas

LoadLimit

Define um limite de carga aplicável a um veículo, por exemplo, "este caminhão só pode transportar até 3.500 kg". Consulte loadLimits.

Representação JSON
{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string,
  "costPerKilometer": {
    object (LoadCost)
  },
  "costPerTraveledHour": {
    object (LoadCost)
  }
}
Campos
softMaxLoad

string (int64 format)

Um limite flexível da carga. Consulte costPerUnitAboveSoftMax.

costPerUnitAboveSoftMax

number

Se a carga exceder softMaxLoad ao longo da rota do veículo, a seguinte penalidade de custo será aplicada (apenas uma vez por veículo): (carga - softMaxLoad) * costPerUnitAboveSoftMax. Todos os custos são somados e precisam estar na mesma unidade que Shipment.penalty_cost. Os limites flexíveis só podem ser definidos em tipos que se aplicam apenas a retiradas ou apenas a entregas em todo o modelo.

startLoadInterval

object (Interval)

O intervalo de carga aceitável do veículo no início do trajeto.

endLoadInterval

object (Interval)

O intervalo de carga aceitável do veículo no final do trajeto.

maxLoad

string (int64 format)

A quantidade máxima aceitável de carga.

costPerKilometer

object (LoadCost)

Custo de movimentar uma unidade de carga por um quilômetro para este veículo. Isso pode ser usado como um proxy para o consumo de combustível: se a carga for um peso (em Newtons), carga*quilômetro terá a dimensão de uma energia.

Experimental: consulte https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request para mais detalhes.

costPerTraveledHour

object (LoadCost)

Custo de viajar com uma unidade de carga durante uma hora para este veículo.

Experimental: consulte https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request para mais detalhes.

Intervalo

Intervalo de valores de carga aceitáveis.

Representação JSON
{
  "min": string,
  "max": string
}
Campos
min

string (int64 format)

Uma carga mínima aceitável. Precisa ser ≥ 0. Se os dois forem especificados, min precisará ser ≤ max.

max

string (int64 format)

Uma carga máxima aceitável. Precisa ser ≥ 0. Se não for especificado, a carga máxima não será restrita por esta mensagem. Se os dois forem especificados, min precisará ser ≤ max.

LoadCost

Custo de mover uma unidade de carga durante um Transition. Para uma determinada carga, o custo é a soma de duas partes:

  • min(carga, loadThreshold) * costPerUnitBelowThreshold
  • max(0, carga - loadThreshold) * costPerUnitAboveThreshold

Com esse custo, as soluções preferem atender primeiro às demandas altas ou, de maneira equivalente, fazer as retiradas de demandas altas por último. Por exemplo, se um veículo tiver

load_limit {
  key: "weight"
  value {
    costPerKilometer {
      loadThreshold: 15
      costPerUnitBelowThreshold: 2.0
      costPerUnitAboveThreshold: 10.0
    }
  }
}

e a rota é start,pickup,pickup,delivery,delivery,end com transições:

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 20 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

então o custo incorrido por este LoadCost é (cost_below * load_below * kilometers + cost_above * load_above * kms)

  • transição 0: 0,0
  • transição 1: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transição 2: 2,0 * 15 * 1,0 + 10,0 * (20 - 15) * 1,0 = 80,0
  • transição 3: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transição 4: 0,0

Então, o LoadCost ao longo do trajeto é de 120.

No entanto, se a rota for start,pickup,delivery,pickup,delivery,end com transições:

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

o custo incorrido por esse LoadCost é

  • transição 0: 0,0
  • transição 1: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transição 2: 0,0
  • transição 3: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transição 4: 0,0

Aqui, o LoadCost no trajeto é 40,0.

LoadCost torna as soluções com transições pesadas mais caras.

Experimental: consulte https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request para mais detalhes.

Representação JSON
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
Campos
loadThreshold

string (int64 format)

Quantidade de carga acima da qual o custo de movimentação de uma unidade de carga muda de "costPerUnitBelowThreshold" para "costPerUnitAboveThreshold". Precisa ser >= 0.

costPerUnitBelowThreshold

number

Custo de movimentação de uma unidade de carga, para cada unidade entre 0 e o limite. Precisa ser um valor finito e >= 0.

costPerUnitAboveThreshold

number

Custo de movimentação de uma unidade de carga para cada unidade acima do limite. No caso especial em que o limite é igual a 0, esse é um custo fixo por unidade. Precisa ser um valor finito e >= 0.

DurationLimit

Um limite que define uma duração máxima do trajeto de um veículo. Ele pode ser físico ou digital.

Quando um campo de limite flexível é definido, o limite máximo flexível e o custo associado precisam ser definidos juntos.

Representação JSON
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
Campos
maxDuration

string (Duration format)

Um limite fixo que restringe a duração a, no máximo, maxDuration.

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

softMaxDuration

string (Duration format)

Um limite flexível que não impõe uma duração máxima, mas que, quando violado, gera um custo para a rota. Esse custo é somado a outros custos definidos no modelo, com a mesma unidade.

Se definido, softMaxDuration não pode ser negativo. Se maxDuration também estiver definido, softMaxDuration precisará ser menor que maxDuration.

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

quadraticSoftMaxDuration

string (Duration format)

Um limite flexível que não impõe um limite de duração máxima, mas que, quando violado, faz com que a rota incorra em um custo quadrático na duração. Esse custo é somado a outros custos definidos no modelo, com a mesma unidade.

Se definido, quadraticSoftMaxDuration não pode ser negativo. Se maxDuration também estiver definido, quadraticSoftMaxDuration precisará ser menor que maxDuration, e a diferença não poderá ser maior que um dia:

maxDuration - quadraticSoftMaxDuration <= 86400 seconds

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

costPerHourAfterSoftMax

number

Custo por hora incorrido se o limite de softMaxDuration for violado. O custo adicional é 0 se a duração for inferior ao limite. Caso contrário, o custo depende da duração da seguinte forma:

  costPerHourAfterSoftMax * (duration - softMaxDuration)

O custo não pode ser negativo.

costPerSquareHourAfterQuadraticSoftMax

number

Custo por hora quadrada incorrido se o limite de quadraticSoftMaxDuration for violado.

O custo adicional é 0 se a duração for inferior ao limite. Caso contrário, o custo depende da duração da seguinte forma:

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

O custo não pode ser negativo.

DistanceLimit

Um limite que define uma distância máxima que pode ser percorrida. Ele pode ser físico ou digital.

Se um limite flexível for definido, softMaxMeters e costPerKilometerAboveSoftMax precisarão ser definidos e não negativos.

Representação JSON
{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}
Campos
maxMeters

string (int64 format)

Um limite fixo que restringe a distância a no máximo maxMeters. O limite não pode ser negativo.

softMaxMeters

string (int64 format)

Um limite flexível que não impõe um limite máximo de distância, mas, quando violado, resulta em um custo que se soma a outros custos definidos no modelo, com a mesma unidade.

Se definido, "softMaxMeters" precisa ser menor que "maxMeters" e não negativo.

costPerKilometerBelowSoftMax

number

Custo por quilômetro incorrido, aumentando até softMaxMeters, com a fórmula:

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

Esse custo não é compatível com routeDistanceLimit.

costPerKilometerAboveSoftMax

number

Custo por quilômetro incorrido se a distância estiver acima do limite de softMaxMeters. O custo adicional é 0 se a distância estiver abaixo do limite. Caso contrário, a fórmula usada para calcular o custo é a seguinte:

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

O custo não pode ser negativo.

BreakRule

Regras para gerar intervalos de tempo para um veículo (por exemplo, intervalos para almoço). Uma pausa é um período contínuo em que o veículo permanece parado na posição atual e não pode fazer nenhuma visita. Uma interrupção pode ocorrer:

  • durante o deslocamento entre duas visitas (incluindo o tempo imediatamente antes ou depois de uma visita, mas não no meio dela), caso em que ele estende o tempo de trânsito correspondente entre as visitas;
  • ou antes da partida do veículo (ele não pode ser ligado no meio de uma pausa). Nesse caso, o horário de partida não é afetado.
  • ou após o fim da viagem (idem, com o horário de término da viagem).
Representação JSON
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
Campos
breakRequests[]

object (BreakRequest)

Sequência de intervalos. Confira a mensagem BreakRequest.

frequencyConstraints[]

object (FrequencyConstraint)

Vários FrequencyConstraint podem ser aplicados. Todos precisam ser atendidos pelos BreakRequests deste BreakRule. Consulte FrequencyConstraint.

BreakRequest

A sequência de intervalos (ou seja, número e ordem) aplicados a cada veículo precisa ser conhecida antecipadamente. Os BreakRequests repetidos definem essa sequência, na ordem em que precisam ocorrer. Os intervalos de tempo (earliestStartTime / latestStartTime) podem se sobrepor, mas precisam ser compatíveis com a ordem (isso é verificado).

Representação JSON
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
Campos
earliestStartTime

string (Timestamp format)

Obrigatório. Limite inferior (inclusivo) do início do intervalo.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

latestStartTime

string (Timestamp format)

Obrigatório. Limite superior (inclusivo) do início do intervalo.

Usa o padrão RFC 3339, em que a saída gerada é sempre convertida em Z e tem 0, 3, 6 ou 9 dígitos fracionários. Além de "Z", outros ajustes também são aceitos. Exemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

minDuration

string (Duration format)

Obrigatório. Duração mínima do intervalo. Precisa ser positivo.

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

FrequencyConstraint

É possível restringir ainda mais a frequência e a duração dos intervalos especificados acima, aplicando uma frequência mínima, como "É necessário fazer um intervalo de pelo menos uma hora a cada 12 horas". Supondo que isso possa ser interpretado como "Em qualquer janela de tempo móvel de 12 horas, é necessário haver pelo menos um intervalo de pelo menos uma hora", esse exemplo seria traduzido para o seguinte FrequencyConstraint:

{
   minBreakDuration { seconds: 3600 }         # 1 hour.
   maxInterBreakDuration { seconds: 39600 }  # 11 hours (12 - 1 = 11).
}

O tempo e a duração dos intervalos na solução vão respeitar todas essas restrições, além das janelas de tempo e durações mínimas já especificadas no BreakRequest.

Um FrequencyConstraint pode ser aplicado a intervalos não consecutivos. Por exemplo, a programação a seguir respeita o exemplo "1h a cada 12h":

  04:00 vehicle start
   .. performing travel and visits ..
  09:00 1 hour break
  10:00 end of the break
   .. performing travel and visits ..
  12:00 20-min lunch break
  12:20 end of the break
   .. performing travel and visits ..
  21:00 1 hour break
  22:00 end of the break
   .. performing travel and visits ..
  23:59 vehicle end
Representação JSON
{
  "minBreakDuration": string,
  "maxInterBreakDuration": string
}
Campos
minBreakDuration

string (Duration format)

Obrigatório. Duração mínima do intervalo para essa restrição. Não negativo. Veja a descrição de FrequencyConstraint.

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

maxInterBreakDuration

string (Duration format)

Obrigatório. Extensão máxima permitida de qualquer intervalo de tempo na rota que não inclua, pelo menos parcialmente, uma pausa de duration >= minBreakDuration. Precisa ser positivo.

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

Objetivo

Os objetivos substituem completamente o modelo de custo e, portanto, são incompatíveis com os custos preexistentes. Cada objetivo é mapeado para vários custos predefinidos, por exemplo, veículos, remessas ou atributos de transição.

Experimental: consulte https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request para mais detalhes.

Representação JSON
{
  "type": enum (Type),
  "weight": number
}
Campos
type

enum (Type)

O tipo de objetivo.

weight

number

Quanto esse objetivo deve contar em relação aos outros. Pode ser qualquer número não negativo. Os pesos não precisam somar 1. Os pesos têm como padrão 1,0.

Tipo

O tipo de objetivo que será mapeado para um conjunto de custos.

Tipos enumerados
DEFAULT Um conjunto padrão de custos será usado para garantir uma solução razoável. Observação: esse objetivo pode ser usado sozinho, mas também será sempre adicionado com peso 1,0, como um valor de referência, aos objetivos especificados pelo usuário, se ainda não estiver presente.
MIN_DISTANCE objetivos "MIN". Minimizar a distância total percorrida.
MIN_WORKING_TIME Minimizar o tempo total de trabalho, somado em todos os veículos.
MIN_TRAVEL_TIME Igual ao acima, mas com foco apenas no tempo de viagem.
MIN_NUM_VEHICLES Minimize o número de veículos usados.

DurationDistanceMatrix

Especifica uma matriz de duração e distância dos locais de início e fim da visita e do veículo.

Representação JSON
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
Campos
rows[]

object (Row)

Especifica as linhas da matriz de duração e distância. Ele precisa ter o mesmo número de elementos que ShipmentModel.duration_distance_matrix_src_tags.

vehicleStartTag

string

Tag que define a quais veículos essa matriz de duração e distância se aplica. Se estiver vazio, isso se aplica a todos os veículos, e só pode haver uma única matriz.

Cada início de veículo precisa corresponder a exatamente uma matriz. Ou seja, exatamente um campo startTags precisa corresponder ao vehicleStartTag de uma matriz (e somente dessa matriz).

Todas as matrizes precisam ter um vehicleStartTag diferente.

Linha

Especifica uma linha da matriz de duração e distância.

Representação JSON
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
Campos
durations[]

string (Duration format)

Valores de duração para uma determinada linha. Ele precisa ter o mesmo número de elementos que ShipmentModel.duration_distance_matrix_dst_tags.

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

meters[]

number

Valores de distância para uma determinada linha. Se não houver custos ou restrições relacionados a distâncias no modelo, deixe em branco. Caso contrário, ele precisa ter tantos elementos quanto durations.

TransitionAttributes

Especifica atributos de transições entre duas visitas consecutivas em um trajeto. Vários TransitionAttributes podem ser aplicados à mesma transição. Nesse caso, todos os custos extras são somados, e a restrição ou o limite mais rígido é aplicado (seguindo a semântica natural "E").

Representação JSON
{
  "srcTag": string,
  "excludedSrcTag": string,
  "dstTag": string,
  "excludedDstTag": string,
  "cost": number,
  "costPerKilometer": number,
  "distanceLimit": {
    object (DistanceLimit)
  },
  "delay": string
}
Campos
srcTag

string

Tags que definem o conjunto de transições (origem -> destino) a que esses atributos se aplicam.

Uma visita à origem ou um início de veículo corresponderá se o VisitRequest.tags ou Vehicle.start_tags contiver srcTag ou não contiver excludedSrcTag (dependendo de qual desses dois campos não está vazio).

excludedSrcTag

string

Consulte srcTag. Exatamente um entre srcTag e excludedSrcTag não pode estar vazio.

dstTag

string

Uma visita ao destino ou um fim de viagem de veículo corresponderá se o VisitRequest.tags ou o Vehicle.end_tags contiver dstTag ou não contiver excludedDstTag (dependendo de qual desses dois campos não está vazio).

excludedDstTag

string

Consulte dstTag. Exatamente um entre dstTag e excludedDstTag não pode estar vazio.

cost

number

Especifica um custo para realizar essa transição. Essa unidade é a mesma de todos os outros custos no modelo e não pode ser negativa. Ela é aplicada sobre todos os outros custos atuais.

costPerKilometer

number

Especifica um custo por quilômetro aplicado à distância percorrida durante essa transição. Ele é adicionado a qualquer Vehicle.cost_per_kilometer especificado nos veículos.

distanceLimit

object (DistanceLimit)

Especifica um limite para a distância percorrida durante essa transição.

Desde 06/2021, apenas limites flexíveis são aceitos.

delay

string (Duration format)

Especifica um atraso incorrido ao realizar essa transição.

Esse atraso sempre ocorre depois de terminar a visita de origem e antes de começar a visita de destino.

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

ShipmentTypeIncompatibility

Especifica incompatibilidades entre remessas dependendo do shipmentType. A aparência de envios incompatíveis na mesma rota é restrita com base no modo de incompatibilidade.

Representação JSON
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
Campos
types[]

string

Lista de tipos incompatíveis. Dois envios com shipment_types diferentes entre os listados são "incompatíveis".

incompatibilityMode

enum (IncompatibilityMode)

Modo aplicado à incompatibilidade.

IncompatibilityMode

Modos que definem como a aparência de envios incompatíveis é restrita na mesma rota.

Tipos enumerados
INCOMPATIBILITY_MODE_UNSPECIFIED Modo de incompatibilidade não especificado. Esse valor nunca pode ser usado.
NOT_PERFORMED_BY_SAME_VEHICLE Nesse modo, dois envios com tipos incompatíveis nunca podem compartilhar o mesmo veículo.
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

Nesse modo, dois envios com tipos incompatíveis nunca podem estar no mesmo veículo ao mesmo tempo:

  • Eles só podem compartilhar o mesmo veículo se um for entregue antes que o outro seja retirado.
  • Quando os dois envios são apenas para retirada (sem entregas) ou apenas para entrega (sem retiradas), eles não podem compartilhar o mesmo veículo.

ShipmentTypeRequirement

Especifica requisitos entre envios com base no shipmentType. As especificidades do requisito são definidas pelo modo de requisito.

Representação JSON
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
Campos
requiredShipmentTypeAlternatives[]

string

Lista de tipos de frete alternativos exigidos pelo dependentShipmentTypes.

dependentShipmentTypes[]

string

Todas as remessas com um tipo no campo dependentShipmentTypes exigem que pelo menos uma remessa do tipo requiredShipmentTypeAlternatives seja visitada no mesmo trajeto.

OBSERVAÇÃO: não são permitidas cadeias de requisitos em que um shipmentType depende de si mesmo.

requirementMode

enum (RequirementMode)

Modo aplicado ao requisito.

RequirementMode

Modos que definem a aparência de envios dependentes em um trajeto.

Tipos enumerados
REQUIREMENT_MODE_UNSPECIFIED Modo de requisito não especificado. Esse valor nunca pode ser usado.
PERFORMED_BY_SAME_VEHICLE Nesse modo, todas as remessas "dependentes" precisam compartilhar o mesmo veículo que pelo menos uma das remessas "obrigatórias".
IN_SAME_VEHICLE_AT_PICKUP_TIME

No modo IN_SAME_VEHICLE_AT_PICKUP_TIME, todas as remessas "dependentes" precisam ter pelo menos uma remessa "obrigatória" no veículo no momento da coleta.

Portanto, uma retirada de envio "dependente" precisa ter:

  • Uma entrega "obrigatória" feita na rota depois ou
  • Uma entrega "obrigatória" foi retirada na rota antes dela, e se a entrega "obrigatória" tiver uma entrega, ela deverá ser realizada após a retirada da entrega "dependente".
IN_SAME_VEHICLE_AT_DELIVERY_TIME Igual ao anterior, exceto que as entregas "dependentes" precisam ter uma entrega "obrigatória" no veículo no momento da entrega.

PrecedenceRule

Uma regra de precedência entre dois eventos (cada evento é a coleta ou a entrega de uma remessa): o evento "segundo" precisa começar pelo menos offsetDuration depois que o "primeiro" começar.

Várias precedências podem se referir aos mesmos eventos (ou relacionados), por exemplo: "a retirada de B acontece após a entrega de A" e "a retirada de C acontece após a retirada de B".

Além disso, as precedências só se aplicam quando os dois envios são realizados e são ignoradas caso contrário.

Representação JSON
{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}
Campos
firstIsDelivery

boolean

Indica se o evento "first" é uma entrega.

secondIsDelivery

boolean

Indica se o evento "segundo" é uma entrega.

offsetDuration

string (Duration format)

O deslocamento entre o primeiro e o segundo evento. Ele pode ser negativo.

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

firstIndex

integer

Índice de envio do evento "first". Este campo precisa ser especificado.

secondIndex

integer

Índice de envio do segundo evento. Este campo precisa ser especificado.