ShipmentModel

Um modelo de remessa contém um conjunto de remessas que precisam ser realizadas 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 de todos os veículos).
  • as penalidades por remessa não realizada.
  • o custo da duração global das remessas
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 remessas que precisam ser realizadas 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 pode ter custo financeiro. 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 menor que um ano, ou seja, o globalEndTime e o globalStartTime precisam estar dentro de 31.536. 000 segundos um do outro.

Ao usar campos cost_per_*hour, talvez seja interessante definir essa janela como um intervalo menor para aumentar o desempenho. Por exemplo, se você modelar um único dia, defina os limites de tempo globais 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, 00:00:00 UTC, 1º de janeiro de 1971 (ou seja, segundos: 31536000, 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".

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 job, 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 usadas, 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.
  • 1 veículo que começa o trajeto em locA e termina em locA.
  • 1 solicitação de visita de retirada no 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.
  • 1 veículo que inicia o trajeto em locA e termina em locB, usando a matriz "fast".
  • 1 veículo que inicia o trajeto em locB e termina em locB, usando a matriz "slow".
  • 1 veículo que inicia o trajeto em locB e termina em locB, usando a matriz "fast".
  • 1 pedido de visita para retirada no 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 origens das matrizes de duração e distância. durationDistanceMatrices(i).rows(j) define as durações e distâncias das 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. Da mesma forma, as tags de origem e destino de um VisitRequest podem ser iguais. Todas as tags precisam ser diferentes e não podem ser strings vazias. Se esse campo não estiver vazio, durationDistanceMatrices não poderá estar vazio.

durationDistanceMatrixDstTags[]

string

Tags que definem os destinos das matrizes de duração e distância; durationDistanceMatrices(i).rows(j).durations(k) (resp. 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. Da mesma forma, as tags de origem e destino de um VisitRequest podem ser iguais. Todas as tags precisam ser diferentes e não podem ser strings vazias. Se esse campo não estiver vazio, durationDistanceMatrices não poderá estar vazio.

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 de 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 com muitas remessas podem ser rejeitadas.

maxActiveVehicles

integer

Restringe o número máximo de veículos ativos. Um veículo estará ativo se o trajeto dele realizar pelo menos um envio. Isso pode ser usado para limitar o número de trajetos quando há menos motoristas do que veículos e a frota de veículos é heterogênea. A otimização vai selecionar o melhor subconjunto de veículos para usar. Precisa ser estritamente positivo.

Envio

O envio de um único item, de uma das retiradas até uma das entregas. Para que a remessa seja considerada realizada, um veículo exclusivo precisa visitar um dos locais de retirada (e diminuir as capacidades de reserva de acordo) e, em seguida, visitar um dos locais de entrega (e, portanto, aumentar novamente as capacidades de reserva 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 definido pelo usuário da remessa. Ele pode ter até 63 caracteres e usar caracteres UTF-8.

pickups[]

object (VisitRequest)

Conjunto de alternativas de retirada associadas à remessa. 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 da remessa (por exemplo, peso, volume, número de paletes etc.). As chaves no mapa precisam ser identificadores que descrevem o tipo de carga correspondente, de preferência incluindo também as unidades. Por exemplo: "weight_kg", "volume_gallons", "pallet_count" 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 realizar essa entrega. Se estiver vazio, todos os veículos poderão realizar a tarefa. Os veículos são fornecidos pelo índice na lista vehicles de ShipmentModel.

costsPerVehicle[]

number

Especifica o custo incorrido quando essa remessa é entregue por cada veículo. Se especificado, ele precisa ter:

  • 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 i-ésimo elemento corresponde ao veículo #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 esses custos.

costsPerVehicleIndices[]

integer

Índices dos veículos aos quais costsPerVehicle se aplica. Se não estiver vazio, ele precisa 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 trajeto mais curto da retirada até a entrega. Se especificado, ele precisa ser não negativo, e a remessa precisa conter pelo menos uma retirada 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 de pickupToDeliveryAbsoluteDetourLimit aplica:

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

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

pickupToDeliveryTimeLimit

string (Duration format)

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

shipmentType

string

String não vazia que especifica um "tipo" para essa remessa. 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 coletas/entregas que pertencem à mesma remessa compartilham o mesmo shipmentType.

label

string

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

ignore

boolean

Se for verdadeiro, pule esta remessa, mas não aplique um penaltyCost.

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

É permitido ignorar uma remessa realizada em injectedFirstSolutionRoutes ou injectedSolutionConstraint. O solucionador remove as visitas de retirada/entrega relacionadas da rota de realização. precedenceRules que se referem a remessas ignoradas também serão ignorados.

penaltyCost

number

Se a remessa não for concluída, essa penalidade será adicionada ao custo geral das rotas. 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 ao custo 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 trajeto mais curto da retirada até a entrega. Se especificado, ele precisa ser não negativo, e a remessa precisa conter pelo menos uma retirada 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 de pickupToDeliveryRelativeDetourLimit aplica:

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

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

VisitRequest

Solicitação de uma visita que pode ser feita por um veículo: tem uma localização geográfica (ou duas, veja abaixo), horários de abertura e fechamento representados por janelas de tempo e uma duração de serviço (tempo gasto pelo veículo depois de chegar 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 localização geográfica em que o veículo chega ao realizar essa VisitRequest. Se o modelo de remessa tiver matrizes de distância de duração, arrivalLocation não poderá ser especificado.

arrivalWaypoint

object (Waypoint)

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

departureLocation

object (LatLng)

A localização geográfica de onde o veículo parte depois de concluir este VisitRequest. Pode ser omitido se for igual a arrivalLocation. Se o modelo de remessa tiver matrizes de distância de duração, departureLocation não poderá ser especificado.

departureWaypoint

object (Waypoint)

O waypoint de onde o veículo sai depois de concluir este VisitRequest. Pode ser omitido se for igual a arrivalWaypoint. Se o modelo de remessa tiver matrizes de distância de duração, departureWaypoint não poderá ser especificado.

tags[]

string

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

timeWindows[]

object (TimeWindow)

Janelas de tempo que restringem o horário de chegada em uma visita. Um veículo pode sair fora da janela de horário de chegada, ou seja, o horário de chegada + a duração não precisam estar dentro de uma janela de horário. 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 realizar essa visita a qualquer momento.

As janelas de tempo precisam ser separadas, ou seja, nenhuma janela de tempo pode se sobrepor ou ser adjacente a outra, e elas precisam estar em ordem crescente.

costPerHourAfterSoftEndTime e softEndTime só podem ser definidos se houver uma única janela de tempo.

duration

string (Duration format)

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

cost

number

Custo para atender a essa solicitação de visita em uma rota 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))

Carregue as demandas dessa 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 as conversões devem ser evitadas em trajetos de carro nesse local. A prevenção de retornos é feita da melhor forma possível, e não há garantia de que eles serão totalmente evitados. Este é um recurso experimental, e o comportamento 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 waypoint. Os waypoints 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,

  // The following is a list of mutually exclusive fields. At most one of the
  // fields will be set in a response:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of mutually exclusive fields.
}
Campos
sideOfRoad

boolean

Opcional. Indica que o local desse waypoint deve ter uma preferência para que o veículo pare em um lado específico da via. Quando você define esse valor, o trajeto passa pelo local para que o veículo possa parar no lado da via em que o local está, em relação ao centro da via. Essa opção não funciona para o modo de viagem "WALKING".

vehicleStopover

boolean

Indica que o waypoint é destinado à parada de veículos, com a intenção de embarque ou desembarque. Essa opção funciona apenas para o modo de viagem "DRIVING" e quando o "locationType" é "location".

Experimental: o comportamento ou a existência desse campo pode mudar no futuro.

Diferentes maneiras de representar um local. Confira a seguir uma lista de campos mutuamente exclusivos. No máximo um dos campos será definido em uma resposta:
location

object (Location)

Um ponto especificado usando coordenadas geográficas, incluindo uma direção opcional.

placeId

string

O ID de lugar do PDI associado ao waypoint.

Ao usar um ID de lugar para especificar o local de chegada ou partida de um VisitRequest, use um ID de lugar que seja 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 que representa uma estrada não é recomendado.

Fim dos campos mutuamente exclusivos.

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 waypoint.

heading

integer

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

TimeWindow

As janelas de tempo limitam 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 rígidos de janela de tempo, startTime e endTime, aplicam 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 ocorra 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 ocorra em softEndTime ou antes, incorrendo em um custo proporcional ao tempo após softEndTime em que o evento ocorre. 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 da janela de tempo rígida. Se não for especificado, ele 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 rígido. Se não for especificado, ele 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 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".

softEndTime

string (Timestamp format)

O horário de término flexível da janela de tempo.

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

Modelos de um veículo em um problema de envio. Resolver um problema de envio vai criar um trajeto que começa em startLocation e termina 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 que o veículo pode usar e a velocidade dele. Consulte também travelDurationMultiple.

routeModifiers

object (RouteModifiers)

Um conjunto de condições que afetam a forma como os trajetos são calculados para o veículo em questão.

startLocation

object (LatLng)

Localização geográfica em que o veículo começa antes de coletar as remessas. Se não for especificado, o veículo vai começar na primeira retirada. Se o modelo de remessa tiver matrizes de duração e distância, startLocation não poderá ser especificado.

startWaypoint

object (Waypoint)

Ponto de passagem que representa uma localização geográfica em que o veículo começa antes de retirar as remessas. Se nem startWaypoint nem startLocation forem especificados, o veículo vai começar na primeira retirada. Se o modelo de remessa 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 o último VisitRequest. Se não for especificado, o ShipmentRoute do veículo vai terminar imediatamente quando ele concluir o último VisitRequest. Se o modelo de remessa tiver matrizes de duração e distância, endLocation não poderá ser especificado.

endWaypoint

object (Waypoint)

Waypoint que representa uma localização geográfica onde 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 ele concluir o último VisitRequest. Se o modelo de remessa tiver matrizes de duração e distância, endWaypoint não poderá ser especificado.

startTags[]

string

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

Não é permitido usar strings vazias ou duplicadas.

endTags[]

string

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

Não é permitido usar strings vazias ou duplicadas.

startTimeWindows[]

object (TimeWindow)

Janelas de tempo 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 desses limites de tempo globais.

As janelas de tempo que pertencem ao mesmo campo repetido precisam ser separadas, ou seja, nenhuma janela de tempo pode se sobrepor ou ser adjacente a outra, e elas precisam estar em ordem cronológica.

costPerHourAfterSoftEndTime e softEndTime só podem ser definidos se houver uma única janela de tempo.

endTimeWindows[]

object (TimeWindow)

Janelas de tempo em que o veículo pode chegar ao local final. 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 desses limites de tempo globais.

As janelas de tempo que pertencem ao mesmo campo repetido precisam ser separadas, ou seja, nenhuma janela de tempo pode se sobrepor ou ser adjacente a outra, e elas precisam estar em ordem cronológica.

costPerHourAfterSoftEndTime e softEndTime só podem ser definidos se houver uma única janela de tempo.

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 que Shipment.penalty_cost.

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

costPerTraveledHour

number

Custo por hora percorrida 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 do trajeto 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 até o departureLocation de um único VisitRequest.

fixedCost

number

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

usedIfRouteIsEmpty

boolean

Esse campo só se aplica a veículos quando o trajeto deles não atende a nenhuma remessa. Indica se o veículo deve ser considerado como usado ou não nesse caso.

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

Caso contrário, ele não vai do local de início ao de término, e nenhum breakRule ou atraso (de TransitionAttributes) é 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 uma determinada OptimizeToursResponse, a duração do trajeto de um veículo é a diferença entre vehicleEndTime e 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 do trajeto é 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 que será gasto 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 uma solicitação 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 a este veículo. Se estiver vazio, nenhum intervalo será programado para esse veículo.

label

string

Especifica um rótulo para este 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 não será usado.

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

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

travelDurationMultiple

number

Especifica um fator multiplicativo que pode ser usado para aumentar ou diminuir os tempos de viagem desse veículo. Por exemplo, definir esse valor como 2,0 significa que o veículo é mais lento e tem tempos de viagem duas vezes maiores do que os de veículos padrão. Esse múltiplo não afeta a duração das visitas. Ele 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 meios de transporte da API Routes da Plataforma Google Maps. Consulte: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode

Observação: as rotas de WALKING estão na versão Beta e, às vezes, podem não ter calçadas ou caminhos claros para pedestres. Esse aviso precisa ser mostrado ao usuário em todos os trajetos a pé exibidos no app.

Tipos enumerados
TRAVEL_MODE_UNSPECIFIED Meio de transporte não especificado, equivalente a DRIVING.
DRIVING Modo de viagem correspondente a rotas de carro.
WALKING Meio de transporte correspondente a rotas a pé.
TWO_WHEELER Veículo motorizado de duas rodas. Por exemplo, motocicleta. Isso é diferente do modo de viagem BICICLETA, que abrange o modo de transporte humano. Esse modo de transporte está disponível apenas nos países listados em Países e regiões com suporte para veículos de duas rodas.

RouteModifiers

Encapsula um conjunto de condições opcionais que precisam ser atendidas 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. Será dada preferência a rotas que não contenham vias com pedágio. Aplica-se apenas a meios de transporte motorizados.

avoidHighways

boolean

Especifica se é preciso evitar rodovias quando possível. A preferência será dada a rotas que não contenham rodovias. Aplica-se apenas a meios de transporte motorizados.

avoidFerries

boolean

Especifica se é preciso evitar balsas quando possível. Será dada preferência a rotas que não incluam viagens de balsa. Aplica-se apenas a meios de transporte motorizados.

avoidIndoor

boolean

Opcional. Especifica se é preciso evitar a navegação em ambientes fechados, quando possível. Será dada preferência a rotas que não contenham navegação interna. Aplica-se apenas ao meio de transporte WALKING.

UnloadingPolicy

Política sobre como um veículo pode ser descarregado. Aplica-se apenas a remessas que têm uma retirada e uma entrega.

Outras remessas podem ocorrer em qualquer lugar do trajeto, independentemente de unloadingPolicy.

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

LoadLimit

Define um limite de carga que se aplica 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 do trajeto desse 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 mover 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), então 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 quantidades 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 ambos forem especificados, min precisa ser ≤ max.

max

string (int64 format)

Uma carga máxima aceitável. Precisa ser ≥ 0. Se não for especificada, a carga máxima não será restrita por essa mensagem. Se ambos forem especificados, min precisa 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(load, loadThreshold) * costPerUnitBelowThreshold
  • max(0, load - loadThreshold) * costPerUnitAboveThreshold

Com esse custo, as soluções preferem entregar as demandas altas primeiro ou, de forma equivalente, retirar as 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 o trajeto é início,retirada,retirada,entrega,entrega,fim com as 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 esse LoadCost é (cost_below * load_below * quilômetros + 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

Portanto, o LoadCost no trajeto é 120,0.

No entanto, se o trajeto for início,retirada,entrega,retirada,entrega,fim 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 sobre o 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 mover uma unidade de carga muda de costPerUnitBelowThreshold para costPerUnitAboveThreshold. Precisa ser >= 0.

costPerUnitBelowThreshold

number

Custo de mover uma unidade de carga, para cada unidade entre 0 e o limite. Precisa ser um valor finito e maior ou igual a 0.

costPerUnitAboveThreshold

number

Custo de mover uma unidade de carga para cada unidade acima do limite. No caso especial de limite = 0, esse é um custo fixo por unidade. Precisa ser um valor finito e maior ou igual a 0.

DurationLimit

Um limite que define a duração máxima do trajeto de um veículo. Ele pode ser rígido ou flexível.

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 rígido que restringe a duração a, no máximo, maxDuration.

softMaxDuration

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 tenha um custo. Esse custo é adicionado a outros custos definidos no modelo, com a mesma unidade.

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

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 é adicionado a outros custos definidos no modelo, com a mesma unidade.

Se quadraticSoftMaxDuration estiver definido, as seguintes condições precisarão ser atendidas:

  • Não pode ser negativo.
  • maxDuration precisa ser definido.
  • quadraticSoftMaxDuration precisa ser menor que maxDuration.
  • A diferença não pode ser maior que um dia: maxDuration - quadraticSoftMaxDuration <= 86400 seconds
costPerHourAfterSoftMax

number

Custo por hora incorrido se o limite de softMaxDuration for violado. O custo adicional será 0 se a duração estiver abaixo do limite. Caso contrário, o custo vai depender da duração, conforme indicado abaixo:

  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 será 0 se a duração estiver abaixo do limite. Caso contrário, o custo vai depender da duração, conforme indicado abaixo:

  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 rígido ou flexível.

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 rígido 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 que, 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 pode ser 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 é aceito em 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 ocioso na posição atual e não pode realizar nenhuma visita. Uma interrupção pode ocorrer:

  • durante o trajeto entre duas visitas (incluindo o tempo imediatamente antes ou depois de uma visita, mas não no meio dela), o que estende o tempo em trânsito correspondente entre as visitas;
  • ou antes do início do veículo (o veículo não pode iniciar no meio de um intervalo). Nesse caso, o horário de início do veículo não é afetado.
  • ou após o fim do veículo (idem, com o horário de término do veículo).
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, o número e a ordem deles) que se aplicam a cada veículo precisa ser conhecida com antecedência. Os BreakRequests repetidos definem essa sequência, na ordem em que precisam ocorrer. As janelas de tempo (earliestStartTime / latestStartTime) podem se sobrepor, mas precisam ser compatíveis com o pedido (isso é verificado).

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

string (Timestamp format)

Obrigatório. Limite inferior (inclusivo) no 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) no 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.

FrequencyConstraint

É possível restringir ainda mais a frequência e a duração dos intervalos especificados acima, aplicando uma frequência mínima de intervalo, como "É preciso haver um intervalo de pelo menos 1 hora a cada 12 horas". Supondo que isso possa ser interpretado como "Em qualquer período de 12 horas, é preciso 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 das durações mínimas já especificadas no BreakRequest.

Um FrequencyConstraint pode, na prática, ser aplicado a intervalos não consecutivos. Por exemplo, a programação a seguir segue 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.

maxInterBreakDuration

string (Duration format)

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

Objetivo

Os objetivos substituem completamente o modelo de custo e, portanto, são incompatíveis com os custos preexistentes. Cada objetivo é associado a vários custos predefinidos, por exemplo, para veículos, envios 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 do 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 padrão sã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 referência, aos objetivos especificados pelo usuário, se ainda não estiver presente.
MIN_DISTANCE "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 anterior, mas com foco apenas no tempo de viagem.
MIN_NUM_VEHICLES Minimizar o número de veículos usados.

DurationDistanceMatrix

Especifica uma matriz de duração e distância dos locais de início da visita e do veículo até os locais de término 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 dos campos 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 de uma determinada linha. Ele precisa ter o mesmo número de elementos que ShipmentModel.duration_distance_matrix_dst_tags.

meters[]

number

Valores de distância para uma determinada linha. Se nenhum custo ou restrição se referir a distâncias no modelo, esse campo poderá ser deixado em branco. Caso contrário, ele precisará 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 rigoroso é aplicado (seguindo a semântica natural "AND").

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 (src->dst) a que esses atributos se aplicam.

Uma visita de origem ou início de veículo corresponde se o VisitRequest.tags ou Vehicle.start_tags contém srcTag ou não contém excludedSrcTag (dependendo de qual desses dois campos não está vazio).

excludedSrcTag

string

Consulte srcTag. Exatamente um dos campos srcTag e excludedSrcTag precisa ser preenchido.

dstTag

string

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

excludedDstTag

string

Consulte dstTag. Exatamente um dos campos dstTag e excludedDstTag precisa ser preenchido.

cost

number

Especifica um custo para realizar essa transição. Ele está na mesma unidade que todos os outros custos no modelo e não pode ser negativo. Ela é aplicada sobre todos os outros custos.

costPerKilometer

number

Especifica um custo por quilômetro aplicado à distância percorrida durante a 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 ao realizar essa transição.

A partir de junho de 2021, apenas limites flexíveis são aceitos.

delay

string (Duration format)

Especifica um atraso ao realizar essa transição.

Esse atraso sempre ocorre depois de terminar a visita de origem e antes de iniciar a visita de destino.

ShipmentTypeIncompatibility

Especifica incompatibilidades entre remessas dependendo do shipmentType. A exibição de remessas 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. Duas remessas com shipment_types diferentes entre as listadas são "incompatíveis".

incompatibilityMode

enum (IncompatibilityMode)

Modo aplicado à incompatibilidade.

IncompatibilityMode

Modos que definem como a aparência de remessas 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, duas remessas com tipos incompatíveis nunca podem compartilhar o mesmo veículo.
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

Nesse modo, duas remessas 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 de o outro ser retirado.
  • Quando as duas remessas são apenas coletas (sem entregas) ou apenas entregas (sem coletas), elas não podem compartilhar o mesmo veículo.

ShipmentTypeRequirement

Especifica os requisitos entre as remessas com base no shipmentType. As especificações 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 envio 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 na mesma rota.

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 remessas 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

Com o 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 retirada.

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

  • Uma remessa "obrigatória" somente de entrega feita na rota depois ou
  • Uma remessa "obrigatória" coletada na rota antes dela e, se a remessa "obrigatória" tiver uma entrega, essa entrega precisará ser realizada após a coleta da remessa "dependente".
IN_SAME_VEHICLE_AT_DELIVERY_TIME Igual ao anterior, exceto que as remessas "dependentes" precisam ter uma remessa "obrigatória" no veículo no momento da entrega.

PrecedenceRule

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

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 as duas remessas são realizadas e, caso contrário, são ignoradas.

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

boolean

Indica se o "primeiro" evento é uma entrega.

secondIsDelivery

boolean

Indica se o "segundo" evento é uma entrega.

offsetDuration

string (Duration format)

O deslocamento entre o "primeiro" e o "segundo" evento. Pode ser negativo.

firstIndex

integer

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

secondIndex

integer

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