ShipmentModel

Un modello di spedizione contiene un insieme di spedizioni che devono essere eseguite da un insieme di veicoli, riducendo al minimo il costo complessivo, che è la somma di:

  • Il costo di transito dei veicoli (somma del costo per tempo totale, costo per tempo di percorrenza e costo fisso su tutti i veicoli).
  • le penalità di spedizione per mancata esecuzione.
  • il costo della durata globale delle spedizioni
Rappresentazione JSON 
{
  "shipments": [
    {
      object (Shipment)
    }
  ],
  "vehicles": [
    {
      object (Vehicle)
    }
  ],
  "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
}
Campi
shipments[]

object (Shipment)

Insieme di spedizioni che devono essere effettuate nel modello.
vehicles[]

object (Vehicle)

Insieme di veicoli che possono essere utilizzati per effettuare visite.
globalStartTime

string (Timestamp format)

Ora di inizio e di fine globali del modello: nessun orario al di fuori di questo intervallo può essere considerato valido.

L'intervallo di tempo del modello deve essere inferiore a un anno, ad esempio globalEndTime e globalStartTime devono rientrare in 31536000 secondi l'uno dall'altro.

Quando utilizzi i campi cost_per_*hour, ti consigliamo di impostare questa finestra su un intervallo più breve per aumentare le prestazioni (ad es. se modelli un singolo giorno, devi impostare i limiti di tempo globali su quel giorno). Se non viene configurato, per impostazione predefinita viene utilizzato il valore 00:00:00 UTC, 1 gennaio 1970 (secondi: 0, nano: 0).

Un timestamp nel formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
globalEndTime

string (Timestamp format)

Se non viene configurato, per impostazione predefinita viene utilizzato il valore 00:00:00 UTC, 1 gennaio 1971 (secondi: 31536000, nano: 0).

Un timestamp in formato "Zulu" UTC RFC3339, con risoluzione a livello di nanosecondo e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
globalDurationCostPerHour

number

La "durata globale" del piano complessivo è la differenza tra l'ora di inizio effettiva più antica e l'ora di fine effettiva più recente di tutti i veicoli. Gli utenti possono assegnare un costo orario a quella quantità per provare, ad esempio, a eseguire l'ottimizzazione prima del completamento del lavoro. Questo costo deve essere nella stessa unità di Shipment.penalty_cost.
durationDistanceMatrices[]

object (DurationDistanceMatrix)

Specifica le matrici di durata e distanza utilizzate nel modello. Se questo campo è vuoto, verranno utilizzate le distanze di Google Maps o geodesiche, a seconda del valore del campo useGeodesicDistances. Se non è vuoto, useGeodesicDistances non può essere vero e né durationDistanceMatrixSrcTags né durationDistanceMatrixDstTags possono essere vuoti.

Esempi di utilizzo:

  • Esistono due località: locA e locB.
  • 1 veicolo che inizia il percorso in locA e lo termina in locA.
  • 1 richiesta di visita per il ritiro presso la 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
    }
  }
}
  • Esistono tre località: locA, locB e locC.
  • 1 veicolo che inizia il percorso in locA e lo termina in locB, utilizzando la matrice "fast".
  • 1 veicolo che inizia il percorso in locB e lo termina in locB, utilizzando la matrice "lenta".
  • 1 veicolo che inizia il percorso in locB e lo termina in locB, utilizzando la matrice "fast".
  • 1 richiesta di visita per il ritiro presso la 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

Tag che definiscono le origini delle matrici di durata e distanza; durationDistanceMatrices(i).rows(j) definisce le durate e le distanze dalle visite con tag durationDistanceMatrixSrcTags(j) alle altre visite nella matrice i.

I tag corrispondono a VisitRequest.tags o Vehicle.start_tags. Un determinato VisitRequest o Vehicle deve corrispondere esattamente a un tag in questo campo. Tieni presente che i tag di origine, di destinazione e della matrice di un Vehicle possono essere gli stessi; analogamente, i tag di origine e di destinazione di un VisitRequest possono essere gli stessi. Tutti i tag devono essere diversi e non possono essere stringhe vuote. Se questo campo non è vuoto, il campo durationDistanceMatrices non deve essere vuoto.
durationDistanceMatrixDstTags[]

string

Tag che definiscono le destinazioni delle matrici di durata e distanza; durationDistanceMatrices(i).rows(j).durations(k) (risp. durationDistanceMatrices(i).rows(j).meters(k)) definisce la durata (rispettivamente la distanza) del viaggio dalle visite con il tag durationDistanceMatrixSrcTags(j) alle visite con il tag durationDistanceMatrixDstTags(k) nella matrice i.

I tag corrispondono a VisitRequest.tags o Vehicle.start_tags. Un determinato VisitRequest o Vehicle deve corrispondere esattamente a un tag in questo campo. Tieni presente che i tag di origine, di destinazione e della matrice di un Vehicle possono essere gli stessi; analogamente, i tag di origine e di destinazione di un VisitRequest possono essere gli stessi. Tutti i tag devono essere diversi e non possono essere stringhe vuote. Se questo campo non è vuoto, durationDistanceMatrices non deve essere vuoto.
transitionAttributes[]

object (TransitionAttributes)

Attributi di transizione aggiunti al modello.
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

Insiemi di tipi di spedizione incompatibili (vedi ShipmentTypeIncompatibility).
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

Insieme di requisiti per shipmentType (vedi ShipmentTypeRequirement).
precedenceRules[]

object (PrecedenceRule)

Insieme di regole di precedenza che devono essere applicate nel modello.
maxActiveVehicles

integer

Limita il numero massimo di veicoli attivi. Un veicolo è attivo se il suo percorso prevede almeno una spedizione. Questo può essere utilizzato per limitare il numero di percorsi nel caso in cui i conducenti siano inferiori ai veicoli e il parco veicoli sia eterogeneo. L'ottimizzazione selezionerà quindi il sottoinsieme migliore di veicoli da utilizzare. Deve essere strettamente positiva.

Spedizione

La spedizione di un singolo articolo, da uno dei suoi ritiri a una delle sue consegne. Affinché la spedizione venga considerata eseguita, un veicolo unico deve recarsi in una delle sedi di prelievo (e diminuire di conseguenza la capacità di riserva), quindi recarsi in una delle sedi di consegna in un secondo momento (quindi aumentare di conseguenza la capacità di riserva).

Rappresentazione 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
}
Campi
displayName

string

Il nome visualizzato della spedizione definito dall'utente. Può avere una lunghezza massima di 63 caratteri e possono essere utilizzati caratteri UTF-8.
pickups[]

object (VisitRequest)

Set di alternative di ritiro associate alla spedizione. Se non specificato, il veicolo deve visitare solo una sede corrispondente alle consegne.
deliveries[]

object (VisitRequest)

Insieme di alternative di consegna associate alla spedizione. Se non specificato, il veicolo deve visitare solo una stazione di ricarica corrispondente ai punti di ritiro.
loadDemands

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

Carica le esigenze della spedizione (ad es. peso, volume, numero di pallet e così via). Le chiavi nella mappa devono essere identificatori che descrivono il tipo di carico corrispondente, idealmente incluse le unità. Ad esempio: "weight_kg", "volume_gallons", "pallet_count" e così via. Se una determinata chiave non viene visualizzata nella mappa, il carico corrispondente viene considerato nullo.
allowedVehicleIndices[]

integer

L'insieme di veicoli che potrebbero effettuare questa spedizione. Se è vuota, può farlo su tutti i veicoli. I veicoli sono indicati in base al relativo indice nell'elenco vehicles di ShipmentModel.
costsPerVehicle[]

number

Specifica il costo sostenuto quando la spedizione viene consegnata da ciascun veicolo. Se specificato, deve avere OPPURE:

  • lo stesso numero di elementi di costsPerVehicleIndices. costsPerVehicle[i] corrisponde al veicolo costsPerVehicleIndices[i] del modello.
  • lo stesso numero di elementi dei veicoli nel modello. L'elemento i corrisponde al veicolo n. i del modello.

Questi costi devono essere nella stessa unità di penaltyCost e non devono essere negativi. Lascia vuoto questo campo se non sono previsti costi di questo tipo.
costsPerVehicleIndices[]

integer

Indici dei veicoli a cui si applica costsPerVehicle. Se non è vuoto, deve avere lo stesso numero di elementi di costsPerVehicle. Un indice di veicoli non può essere specificato più di una volta. Se un veicolo è escluso da costsPerVehicleIndices, il relativo costo è pari a zero.
pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

Specifica il tempo di deviazione assoluto massimo rispetto al percorso più breve dal ritiro alla consegna. Se specificato, non deve essere negativo e la spedizione deve contenere almeno un ritiro e una consegna.

Ad esempio, supponiamo che t sia il tempo più breve necessario per passare dall'opzione di ritiro selezionata direttamente all'opzione di consegna selezionata. Quindi, l'impostazione di pickupToDeliveryAbsoluteDetourLimit applica in modo forzato:

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

Se nella stessa spedizione vengono specificati sia i limiti relativi che quelli assoluti, viene utilizzato il limite più restrittivo per ogni possibile coppia di ritiro/consegna. A partire da ottobre 2017, i percorsi alternativi sono supportati solo quando le durate dei viaggi non dipendono dai veicoli.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".
pickupToDeliveryTimeLimit

string (Duration format)

Specifica la durata massima dall'inizio del ritiro all'inizio della consegna di una spedizione. Se specificato, non deve essere negativo e la spedizione deve contenere almeno un ritiro e una consegna. Ciò non dipende dalle alternative selezionate per il ritiro e la consegna né dalla velocità del veicolo. Questo valore può essere specificato insieme ai vincoli di deviazione massima: la soluzione rispetterà entrambe le specifiche.

Una durata in secondi con un massimo di nove cifre frazionarie, che termina con "s". Esempio: "3.5s".
shipmentType

string

Stringa non vuota che specifica un "type" per la spedizione. Questa funzionalità può essere utilizzata per definire incompatibilità o requisiti tra il giorno shipment_types (vedi shipmentTypeIncompatibilities e shipmentTypeRequirements in ShipmentModel).

Differisce da visitTypes, che è specificato per una singola visita: tutti i ritiri/consegne appartenenti alla stessa spedizione hanno lo stesso shipmentType.
label

string

Specifica un'etichetta per questa spedizione. Questa etichetta viene riportata nella risposta in shipmentLabel del ShipmentRoute.Visit corrispondente.
ignore

boolean

Se il valore è true, salta questa spedizione, ma non applica un penaltyCost.

Se ignori una spedizione, il modello restituisce un errore di convalida se il modello include shipmentTypeRequirements.

Ignorare una spedizione eseguita nei giorni injectedFirstSolutionRoutes o injectedSolutionConstraint è consentita; il risolutore rimuove le relative visite di ritiro/consegna dal percorso di esecuzione. precedenceRules che fanno riferimento alle spedizioni ignorate verranno ignorati.
penaltyCost

number

Se la spedizione non viene completata, questa penale viene aggiunta al costo complessivo dei percorsi. Una spedizione è considerata completata se viene visitata una delle alternative di ritiro e consegna. Il costo può essere espresso nella stessa unità utilizzata per tutti gli altri campi relativi ai costi nel modello e deve essere positivo.

IMPORTANTE: se questa penale non è specificata, è considerata infinita, ovvero la spedizione deve essere completata.
pickupToDeliveryRelativeDetourLimit

number

Specifica il tempo di deviazione massimo rispetto al percorso più breve dal ritiro alla consegna. Se specificato, non deve essere negativo e la spedizione deve contenere almeno un ritiro e una consegna.

Ad esempio, lascia che sia il tempo più breve necessario per passare direttamente dall'alternativa di ritiro selezionata a quella selezionata. Quindi, l'impostazione di pickupToDeliveryRelativeDetourLimit applica in modo forzato:

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

Se nella stessa spedizione vengono specificati limiti sia relativi che assoluti, il limite più vincolante viene utilizzato per ogni possibile coppia di ritiro/consegna. A partire da ottobre 2017, i percorsi alternativi sono supportati solo quando le durate dei viaggi non dipendono dai veicoli.

VisitRequest

Richiesta di una visita che può essere effettuata da un veicolo: ha una geolocalizzazione (o due, vedi di seguito), orari di apertura e chiusura rappresentati da finestre temporali e una durata del servizio (tempo impiegato dal veicolo una volta arrivato per ritirare o consegnare le merci).

Rappresentazione 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
}
Campi
arrivalLocation

object (LatLng)

La geolocalizzazione a cui arriva il veicolo quando esegui questo VisitRequest. Se il modello di spedizione contiene matrici di distanza e durata, arrivalLocation non deve essere specificato.
arrivalWaypoint

object (Waypoint)

Il waypoint a cui arriva il veicolo quando si esegue questo VisitRequest. Se il modello di spedizione ha matrici della durata e della distanza, non è necessario specificare arrivalWaypoint.
departureLocation

object (LatLng)

La geolocalizzazione da cui parte il veicolo al termine di questo VisitRequest. Può essere omesso se è uguale a arrivalLocation. Se il modello di spedizione ha matrici della durata e della distanza, non è necessario specificare departureLocation.
departureWaypoint

object (Waypoint)

La tappa da cui parte il veicolo dopo aver completato questo VisitRequest. Può essere omesso se è uguale a arrivalWaypoint. Se il modello di spedizione ha matrici della durata e della distanza, non è necessario specificare departureWaypoint.
tags[]

string

Specifica i tag associati alla richiesta di visita. Non sono consentite stringhe vuote o duplicate.
timeWindows[]

object (TimeWindow)

Finestre temporali che limitano l'ora di arrivo in una visita. Tieni presente che un veicolo può partire al di fuori dell'intervallo di tempo di arrivo, ovvero l'ora di arrivo + la durata non devono rientrare in un intervallo di tempo. Ciò può comportare dei tempi di attesa se il veicolo arriva prima del giorno TimeWindow.start_time.

L'assenza di TimeWindow indica che il veicolo può effettuare la visita in qualsiasi momento.

Le finestre temporali devono essere disgiunte, ovvero nessuna finestra temporale deve sovrapporsi o essere adiacente a un'altra, e devono essere in ordine crescente.

costPerHourAfterSoftEndTime e softEndTime possono essere impostati solo se esiste una sola finestra temporale.
duration

string (Duration format)

Durata della visita, ossia il tempo trascorso dal veicolo tra l'arrivo e la partenza (da aggiungere al possibile tempo di attesa; consulta timeWindows).

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".
cost

number

Costo per gestire questa richiesta di visita su un percorso di veicoli. Questo può essere utilizzato per pagare costi diversi per ogni ritiro o consegna alternativa di una spedizione. Questo costo deve essere nella stessa unità di Shipment.penalty_cost e non deve essere negativo.
loadDemands

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

Carica le richieste di questa visita. È proprio come il campo Shipment.load_demands, ad eccezione del fatto che si applica solo a questo VisitRequest anziché all'intero campo Shipment. Le richieste elencate qui vengono aggiunte a quelle elencate in Shipment.load_demands.
visitTypes[]

string

Specifica i tipi di visita. In questo modo è possibile assegnare il tempo aggiuntivo necessario a un veicolo per completare la visita (vedi Vehicle.extra_visit_duration_for_visit_type).

Un tipo può essere visualizzato una sola volta.
label

string

Specifica un'etichetta per questo VisitRequest. Questa etichetta viene riportata nella risposta come visitLabel in ShipmentRoute.Visit corrispondente.

LatLng

Un oggetto che rappresenta una coppia di latitudine/longitudine. Questo valore è espresso come una coppia di numeri doppi per rappresentare i gradi di latitudine e di longitudine. Se non diversamente specificato, questo oggetto deve essere conforme allo standard WGS84. I valori devono essere compresi negli intervalli normalizzati.

Rappresentazione JSON 
{
  "latitude": number,
  "longitude": number
}
Campi
latitude

number

La latitudine in gradi. Deve essere compreso nell'intervallo [-90,0, +90,0].
longitude

number

La longitudine in gradi. Deve essere compreso nell'intervallo [-180,0, +180,0].

Waypoint

Incapsula un waypoint. I waypoint contrassegnano le posizioni di arrivo e partenza delle richieste di visita e le posizioni di partenza e di arrivo dei veicoli.

Rappresentazione JSON 
{
  "sideOfRoad": 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.
}
Campi
sideOfRoad

boolean

(Facoltativo) Indica che la posizione di questo waypoint è destinata a avere una preferenza per la fermata del veicolo su un determinato lato della strada. Quando imposti questo valore, il percorso passerà attraverso la località in modo che il veicolo possa fermarsi sul lato della strada verso cui è inclinata la località rispetto al centro della strada. Questa opzione non funziona per la modalità di viaggio "A PIEDI".
Campo unione location_type. Diversi modi per rappresentare un luogo. location_type può essere solo uno dei seguenti:
location

object (Location)

Un punto specificato utilizzando le coordinate geografiche, inclusa un'intestazione facoltativa.
placeId

string

L'ID luogo del PDI associato alla tappa.

Località

Incapsula una posizione (un punto geografico e un'intestazione facoltativa).

Rappresentazione JSON 
{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}
Campi
latLng

object (LatLng)

Le coordinate geografiche del waypoint.
heading

integer

L'intestazione della bussola associata alla direzione del flusso del traffico. Questo valore viene utilizzato per specificare il lato della strada da utilizzare per il ritiro e il reso. I valori di rotta possono variare da 0 a 360, dove 0 indica una rotta a nord, 90 indica una rotta a est e così via.

TimeWindow

Le finestre temporali vincolano l'ora di un evento, come l'ora di arrivo di una visita o l'ora di inizio e di fine di un veicolo.

I limiti fissi di finestre temporali, startTime e endTime, applicano l'ora più vicina e più recente dell'evento, ad esempio startTime <= event_time <= endTime. Il limite inferiore della finestra di tempo flessibile, softStartTime, esprime una preferenza affinché l'evento si verifichi a partire da softStartTime in base a un costo proporzionale al tempo prima del softStartTime dell'evento. Il limite superiore della finestra temporale flessibile, softEndTime, esprime una preferenza per la data e l'ora in cui si verifica l'evento, ovvero prima del giorno softEndTime, comportando un costo proporzionale al tempo che intercorre dopo questa data. startTime, endTime, softStartTime e softEndTime devono rispettare i limiti di tempo globali (vedi ShipmentModel.global_start_time e ShipmentModel.global_end_time) e devono rispettare:

  0 <= `startTime` <= `endTime` and
  0 <= `startTime` <= `softStartTime` and
  0 <= `softEndTime` <= `endTime`.
Rappresentazione JSON 
{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}
Campi
startTime

string (Timestamp format)

L'ora di inizio dell'intervallo di tempo obbligatorio. Se non specificato, verrà impostato su ShipmentModel.global_start_time.

Un timestamp in formato "Zulu" UTC RFC3339, con risoluzione a livello di nanosecondo e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
endTime

string (Timestamp format)

L'ora di fine della finestra temporale massima. Se non specificato, verrà impostato su ShipmentModel.global_end_time.

Un timestamp nel formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
softStartTime

string (Timestamp format)

L'ora di inizio graduale della finestra temporale.

Un timestamp nel formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
softEndTime

string (Timestamp format)

L'ora di fine soft della finestra temporale.

Un timestamp in formato "Zulu" UTC RFC3339, con risoluzione a livello di nanosecondo e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
costPerHourBeforeSoftStartTime

number

Un costo per ora aggiunto ad altri costi nel modello se l'evento si verifica prima di softStartTime, calcolato come:

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

Questo costo deve essere positivo e il campo può essere impostato solo se è stato impostato softStartTime.
costPerHourAfterSoftEndTime

number

Un costo per ora aggiunto agli altri costi del modello se l'evento si verifica dopo softEndTime, calcolato come segue:

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

Questo costo deve essere positivo e il campo può essere impostato solo se è stato impostato softEndTime.

Veicolo

Modella un veicolo in un problema di spedizione. La risoluzione di un problema di spedizione comporterà la creazione di un percorso che parte da startLocation e termina a endLocation per questo veicolo. Un percorso è una sequenza di visite (vedi ShipmentRoute).

Rappresentazione 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
}
Campi
displayName

string

Il nome visualizzato del veicolo definito dall'utente. Può avere una lunghezza massima di 63 caratteri e possono essere utilizzati caratteri UTF-8.
travelMode

enum (TravelMode)

La modalità di viaggio che influisce sulle strade utilizzabili dal veicolo e sulla sua velocità. Vedi anche travelDurationMultiple.
routeModifiers

object (RouteModifiers)

Un insieme di condizioni da soddisfare che influiscono sul modo in cui vengono calcolati i percorsi per un determinato veicolo.
startLocation

object (LatLng)

Posizione geografica in cui il veicolo parte prima di ritirare le spedizioni. Se non specificato, il veicolo si avvia al primo ritiro. Se il modello di spedizione ha matrici di durata e distanza, startLocation non deve essere specificato.
startWaypoint

object (Waypoint)

Waypoint che rappresenta una posizione geografica in cui il veicolo parte prima di ritirare qualsiasi spedizione. Se non viene specificato né startWaypoint né startLocation, il veicolo parte al primo ritiro. Se il modello di spedizione ha matrici di durata e distanza, startWaypoint non deve essere specificato.
endLocation

object (LatLng)

Posizione geografica in cui termina il viaggio del veicolo dopo aver completato l'ultima VisitRequest. Se non specificato, ShipmentRoute del veicolo termina immediatamente quando completa gli ultimi VisitRequest. Se il modello di spedizione ha matrici di durata e distanza, non è necessario specificare endLocation.
endWaypoint

object (Waypoint)

Waypoint che rappresenta una posizione geografica in cui il veicolo termina dopo aver completato l'ultimo VisitRequest. Se non viene specificato né endWaypoint né endLocation, il valore ShipmentRoute del veicolo termina immediatamente quando viene completato l'ultimo VisitRequest. Se il modello di spedizione ha matrici di durata e distanza, endWaypoint non deve essere specificato.
startTags[]

string

Specifica i tag allegati all'inizio del percorso del veicolo.

Non sono consentite stringhe vuote o duplicate.
endTags[]

string

Specifica i tag allegati alla fine del percorso del veicolo.

Non sono consentite stringhe vuote o duplicate.
startTimeWindows[]

object (TimeWindow)

Fasce orarie durante le quali il veicolo può partire dalla stazione di partenza. Devono rientrare nei limiti di tempo globali (vedi i campi ShipmentModel.global_*). Se non specificato, non ci sono limitazioni oltre a questi limiti di tempo globali.

Le finestre temporali appartenenti allo stesso campo ripetuto devono essere disgiunte, ovvero nessuna finestra temporale può sovrapporsi o essere adiacente a un'altra e devono essere in ordine cronologico.

costPerHourAfterSoftEndTime e softEndTime possono essere impostati solo se esiste una sola finestra temporale.
endTimeWindows[]

object (TimeWindow)

Finestre temporali durante le quali il veicolo potrebbe arrivare alla sua posizione di fine. Devono rispettare i limiti di tempo globali (vedi campi ShipmentModel.global_*). Se non specificato, non ci sono limitazioni oltre a questi limiti di tempo globali.

Le finestre temporali appartenenti allo stesso campo ripetuto devono essere disgiunte, ovvero nessuna finestra temporale può sovrapporsi o essere adiacente a un'altra e devono essere in ordine cronologico.

costPerHourAfterSoftEndTime e softEndTime possono essere impostati solo se esiste una singola finestra temporale.
unloadingPolicy

enum (UnloadingPolicy)

Criterio di scarico applicato al veicolo.
loadLimits

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

Capacità del veicolo (ad es. peso, volume, numero di pallet). Le chiavi nella mappa sono gli identificatori del tipo di caricamento, in linea con le chiavi del campo Shipment.load_demands. Se una determinata chiave non è presente in questa mappa, la capacità corrispondente è considerata illimitata.
costPerHour

number

Costi del veicolo: tutti i costi si sommano e devono essere nella stessa unità di Shipment.penalty_cost.

Costo per ora del percorso del veicolo. Questo costo viene applicato al tempo totale impiegato dal percorso e include il tempo di percorrenza, il tempo di attesa e il tempo di visita. L'uso di costPerHour anziché solo di costPerTraveledHour potrebbe causare una latenza aggiuntiva.
costPerTraveledHour

number

Costo per ora di percorrenza del percorso con il veicolo. Questo costo viene applicato solo al tempo di percorrenza previsto per il percorso (ad es. riportato in ShipmentRoute.transitions) ed esclude il tempo di attesa e il tempo di visita.
costPerKilometer

number

Costo per chilometro del percorso del veicolo. Questo costo viene applicato alla distanza riportata nel ShipmentRoute.transitions e non si applica alle distanze percorse implicitamente dal arrivalLocation al departureLocation di un singolo VisitRequest.
fixedCost

number

Costo fisso applicato se questo veicolo viene utilizzato per gestire una spedizione.
usedIfRouteIsEmpty

boolean

Questo campo si applica ai veicoli solo quando il loro percorso non serve spedizioni. Indica se il veicolo deve essere considerato usato o meno in questo caso.

In questo caso, il veicolo va dalla sua posizione di partenza a quella di arrivo anche se non effettua alcuna spedizione e vengono presi in considerazione i costi in termini di tempo e distanza derivanti dall'inizio --> il viaggio finale.

In caso contrario, il veicolo non si sposta dall'inizio alla posizione di fine e non sono previsti breakRule o ritardi (da TransitionAttributes) per questo veicolo. In questo caso, l'elemento ShipmentRoute del veicolo non contiene alcuna informazione ad eccezione dell'indice e dell'etichetta del veicolo.
routeDurationLimit

object (DurationLimit)

Limite applicato alla durata totale del percorso del veicolo. In un determinato OptimizeToursResponse, la durata del percorso di un veicolo è la differenza tra vehicleEndTime e vehicleStartTime.
travelDurationLimit

object (DurationLimit)

Limite applicato alla durata del percorso del veicolo. In un determinato OptimizeToursResponse, la durata del viaggio dell'itinerario è la somma di tutti i suoi transitions.travel_duration.
routeDistanceLimit

object (DistanceLimit)

Limite applicato alla distanza totale del percorso del veicolo. In un determinato OptimizeToursResponse, la distanza del percorso è la somma di tutti i suoi transitions.travel_distance_meters.
extraVisitDurationForVisitType

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

Specifica una mappa dalle stringhe di visitTypes alle durate. La durata è il tempo aggiuntivo di VisitRequest.duration da prendere in considerazione per le visite con il visitTypes specificato. Questa durata della visita aggiuntiva comporta un costo se viene specificato costPerHour. Le chiavi (ad es. visitTypes) non possono essere stringhe vuote.

Se una richiesta di visita ha più tipi, nella mappa verrà aggiunta una durata per ogni tipo.
breakRule

object (BreakRule)

Descrive la programmazione delle interruzioni da applicare a questo veicolo. Se è vuoto, non verranno pianificate interruzioni per questo veicolo.
label

string

Specifica un'etichetta per questo veicolo. Questa etichetta viene riportata nella risposta come vehicleLabel del ShipmentRoute corrispondente.
ignore

boolean

Se true, usedIfRouteIsEmpty deve essere false e il veicolo rimarrà inutilizzato.

Se una spedizione viene eseguita da un veicolo ignorato in injectedFirstSolutionRoutes, viene saltata nella prima soluzione, ma può essere eseguita nella risposta.

Se una spedizione viene eseguita da un veicolo ignorato in injectedSolutionConstraint e l'eventuale ritiro/consegna correlata è vincolato a rimanere sul veicolo (ovvero, non viene rilassato al livello RELAX_ALL_AFTER_THRESHOLD), viene saltata nella risposta. Se una spedizione ha un campo allowedVehicleIndices non vuoto e tutti i veicoli consentiti vengono ignorati, la spedizione viene ignorata nella risposta.
travelDurationMultiple

number

Specifica un fattore moltiplicativo che può essere utilizzato per aumentare o diminuire i tempi di percorrenza di questo veicolo. Ad esempio, se imposti questo valore su 2,0, il veicolo è più lento e i tempi di percorrenza sono il doppio di quelli dei veicoli standard. Questo multiplo non influisce sulla durata delle visite. Influisce sul costo se vengono specificati costPerHour o costPerTraveledHour. Il valore deve essere compreso nell'intervallo [0,001, 1000,0]. Se non viene configurato, il veicolo è standard e questo multiplo è considerato pari a 1, 0.

AVVERTENZA: i tempi di percorrenza verranno arrotondati al secondo più vicino dopo l'applicazione di questo moltiplicatore, ma prima di eseguire qualsiasi operazione numerica. Pertanto, un piccolo moltiplicatore potrebbe comportare una perdita di precisione.

Vedi anche extraVisitDurationForVisitType di seguito.

TravelMode

Modalità di viaggio utilizzabili dai veicoli.

Devono essere un sottoinsieme dei modi di viaggio dell'API Routes Preferred della piattaforma Google Maps, consulta: https://developers.google.com/maps/documentation/routes_preferred/reference/rest/Shared.Types/RouteTravelMode.

Enum
TRAVEL_MODE_UNSPECIFIED Modalità di viaggio non specificata, equivalente a DRIVING.
DRIVING Modalità di viaggio corrispondente alle indicazioni stradali (auto, ...).
WALKING Modalità di viaggio corrispondente alle indicazioni stradali a piedi.

RouteModifiers

Include una serie di condizioni facoltative da soddisfare durante il calcolo dei percorsi dei veicoli. Questo valore è simile a RouteModifiers nell'API Routes Preferred di Google Maps Platform; consulta: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers.

Rappresentazione JSON 
{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}
Campi
avoidTolls

boolean

Specifica se evitare le strade a pedaggio, ove ragionevole. Verrà data la preferenza ai percorsi che non contengono strade a pedaggio. Si applica solo alle modalità di viaggio motorizzate.
avoidHighways

boolean

Specifica se evitare le autostrade, ove possibile. Verrà data la preferenza ai percorsi che non contengono autostrade. Si applica solo alle modalità di viaggio motorizzate.
avoidFerries

boolean

Specifica se evitare i traghetti, ove ragionevole. Verrà data la preferenza ai percorsi che non includono viaggi in traghetto. Si applica solo alle modalità di viaggio motorizzate.
avoidIndoor

boolean

(Facoltativo) Consente di specificare se evitare la navigazione al chiuso dove ragionevole. Verrà data la preferenza ai percorsi che non contengono la navigazione al chiuso. Si applica solo alla modalità di viaggio WALKING.

UnloadingPolicy

Norme sulle modalità di scarico di un veicolo. Si applica solo alle spedizioni con sia un ritiro che una consegna.

Le altre spedizioni possono avvenire in qualsiasi punto del percorso, indipendentemente da unloadingPolicy.

Enum
UNLOADING_POLICY_UNSPECIFIED Criterio di unload non specificato; le consegne devono avvenire solo dopo i ritiri corrispondenti.
LAST_IN_FIRST_OUT Le consegne devono avvenire in ordine inverso rispetto ai ritiri
FIRST_IN_FIRST_OUT Le consegne devono avvenire nello stesso ordine dei ritiri

LoadLimit

Definisce un limite di carico applicabile a un veicolo, ad esempio "questo camion può trasportare solo fino a 3500 kg". Leggi i loadLimits.

Rappresentazione JSON 
{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string,
  "costPerKilometer": {
    object (LoadCost)
  },
  "costPerTraveledHour": {
    object (LoadCost)
  }
}
Campi
softMaxLoad

string (int64 format)

Un limite flessibile del carico. Leggi i costPerUnitAboveSoftMax.
costPerUnitAboveSoftMax

number

Se il carico supera softMaxLoad lungo il percorso di questo veicolo, viene applicata la seguente penale (solo una volta per veicolo): (carico - softMaxLoad) * costPerUnitAboveSoftMax. Tutti i costi si sommano e devono essere nella stessa unità di Shipment.penalty_cost.
startLoadInterval

object (Interval)

L'intervallo di carico accettabile del veicolo all'inizio del percorso.
endLoadInterval

object (Interval)

L'intervallo di carico accettabile del veicolo alla fine del percorso.
maxLoad

string (int64 format)

La quantità massima di carico accettabile.
costPerKilometer

object (LoadCost)

Costo del trasporto di una unità di carico per un chilometro per questo veicolo. Questo può essere utilizzato come sostituto del consumo di carburante: se il carico è un peso (in Newton), il carico per chilometro ha la dimensione di un'energia.
costPerTraveledHour

object (LoadCost)

Costo del viaggio con una unità di carico per un'ora per questo veicolo.

Intervallo

Intervallo di importi di carico accettabili.

Rappresentazione JSON 
{
  "min": string,
  "max": string
}
Campi
min

string (int64 format)

Un carico minimo accettabile. Deve essere ≥ 0. Se sono specificati entrambi, min deve essere ≤ max.
max

string (int64 format)

Un carico massimo accettabile. Deve essere ≥ 0. Se non specificato, il carico massimo non è limitato da questo messaggio. Se sono specificati entrambi, min deve essere ≤ max.

LoadCost

Costo dello spostamento di un'unità di carico durante un Transition. Per un determinato carico, il costo è la somma di due parti:

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

Con questo costo, le soluzioni preferiscono soddisfare prima le richieste elevate o, in modo equivalente, raccogliere le richieste elevate per ultime. Ad esempio, se un veicolo ha

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

e il suo percorso è start,pickup,pickup,delivery,delivery,end con le transizioni:

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 }

il costo sostenuto da questo LoadCost è (cost_ below * load_ below * chilometri + costi_above * load_above * km)

  • transizione 0: 0,0
  • transizione 1: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transizione 2: 2,0 * 15 * 1,0 + 10,0 * (20 - 15) * 1,0 = 80,0
  • transizione 3: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transizione 4: 0,0

Quindi LoadCost lungo il percorso è 120,0.

Tuttavia, se il percorso è inizio,ritiro,consegna,ritiro,consegna,termina con transizioni:

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 }

il costo sostenuto da questo LoadCost è

  • transizione 0: 0.0
  • transizione 1: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transizione 2: 0,0
  • transizione 3: 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transizione 4: 0,0

Qui il valore LoadCost sul percorso è 40.0.

LoadCost rende più costose le soluzioni con transizioni molto complesse.

Rappresentazione JSON 
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
Campi
loadThreshold

string (int64 format)

Quantità di carico al di sopra della quale il costo del trasferimento di una unità di carico passa da costPerUnitBelowThreshold a costPerUnitAboveThreshold. Deve essere >= 0.
costPerUnitBelowThreshold

number

Costo dello spostamento di un'unità di carico, per ogni unità compresa tra 0 e la soglia. Deve essere un valore finito e maggiore o uguale a 0.
costPerUnitAboveThreshold

number

Costo del trasferimento di una unità di carico per ogni unità superiore alla soglia. Nel caso speciale soglia = 0, si tratta di un costo fisso per unità. Deve essere un valore finito e >= 0.

DurationLimit

Un limite che definisce una durata massima del percorso di un veicolo. Può essere dura o morbida.

Quando viene definito un campo del limite flessibile, è necessario definire insieme la soglia massima e il costo associato.

Rappresentazione JSON 
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
Campi
maxDuration

string (Duration format)

Un limite massimo che impone che la durata non superi maxDuration.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".
softMaxDuration

string (Duration format)

Un limite flessibile che non applica un limite di durata massimo, ma in caso di violazione comporta un costo per la route. Questo costo si somma agli altri costi definiti nel modello, con la stessa unità di misura.

Se definito, softMaxDuration deve essere non negativo. Se viene definito anche maxDuration, softMaxDuration deve essere inferiore a maxDuration.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".
quadraticSoftMaxDuration

string (Duration format)

Un limite flessibile non applica un limite di durata massimo, ma se viene violato comporta un costo quadratico nella durata. Questo costo si somma agli altri costi definiti nel modello, con la stessa unità di misura.

Se definito, quadraticSoftMaxDuration deve essere un valore non negativo. Se viene definito anche maxDuration, quadraticSoftMaxDuration deve essere inferiore a maxDuration e la differenza non deve essere superiore a un giorno:

maxDuration - quadraticSoftMaxDuration <= 86400 seconds

Una durata in secondi con un massimo di nove cifre frazionarie, che termina con "s". Esempio: "3.5s".
costPerHourAfterSoftMax

number

Costo orario sostenuto se viene violata la soglia softMaxDuration. Il costo aggiuntivo è pari a 0 se la durata è inferiore alla soglia, altrimenti il costo dipende dalla durata, come segue:

  costPerHourAfterSoftMax * (duration - softMaxDuration)

Il costo non deve essere negativo.
costPerSquareHourAfterQuadraticSoftMax

number

Costo per ora quadrata in caso di violazione della soglia di quadraticSoftMaxDuration.

Il costo aggiuntivo è pari a 0 se la durata è inferiore alla soglia, altrimenti il costo dipende dalla durata, come segue:

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

Il costo non deve essere negativo.

DistanceLimit

Un limite che definisce la distanza massima che può essere percorsa. Può essere difficile o morbida.

Se è definito un limite flessibile, sia softMaxMeters che costPerKilometerAboveSoftMax devono essere definiti e non negativi.

Rappresentazione JSON 
{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}
Campi
maxMeters

string (int64 format)

Un limite rigido che obbliga la distanza a non superare il limite massimo di maxMeters. Il limite non deve essere negativo.
softMaxMeters

string (int64 format)

Un limite flessibile non applica un limite massimo per la distanza, ma se violato genera un costo che si somma ad altri costi definiti nel modello, con la stessa unità.

Se definito il valore softMaxMeters deve essere inferiore a maxMeters e deve essere un numero non negativo.
costPerKilometerBelowSoftMax

number

Costo per chilometro sostenuto, crescente fino a softMaxMeters, con la formula:

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

Questo costo non è supportato in routeDistanceLimit.
costPerKilometerAboveSoftMax

number

Costo per chilometro addebitato se la distanza supera il limite di softMaxMeters. Il costo aggiuntivo è 0 se la distanza è inferiore al limite, altrimenti la formula utilizzata per calcolare il costo è la seguente:

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

Il costo deve essere non negativo.

BreakRule

Regole per generare interruzioni di tempo per un veicolo (ad es. pause pranzo). Una pausa è un periodo di tempo contiguo durante il quale il veicolo rimane inattivo nella sua posizione corrente e non può effettuare alcuna visita. Potrebbe verificarsi una pausa:

  • durante il viaggio tra due visite (che include il tempo immediatamente prima o subito dopo una visita, ma non nel corso di una visita), nel qual caso estende il tempo di transito corrispondente tra una visita e l'altra;
  • o prima dell'avvio del veicolo (il veicolo potrebbe non avviarsi nel bel mezzo di una pausa), nel qual caso l'operazione non influisce sull'ora di inizio del veicolo.
  • o dopo la fine del servizio (idem, con l'ora di fine del servizio).
Rappresentazione JSON 
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
Campi
breakRequests[]

object (BreakRequest)

Sequenza delle interruzioni. Leggi il messaggio di BreakRequest.
frequencyConstraints[]

object (FrequencyConstraint)

Potrebbero essere applicati diversi FrequencyConstraint. Devono essere soddisfatte tutte le BreakRequest di questo BreakRule. Consulta FrequencyConstraint.

BreakRequest

La sequenza delle interruzioni (ovvero il numero e l'ordine) che si applicano a ogni veicolo deve essere nota in anticipo. I valori BreakRequest ripetuti definiscono questa sequenza, nell'ordine in cui devono verificarsi. Le relative finestre temporali (earliestStartTime/latestStartTime) possono sovrapporsi, ma devono essere compatibili con l'ordine (questo viene controllato).

Rappresentazione JSON 
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
Campi
earliestStartTime

string (Timestamp format)

Obbligatorio. Limite inferiore (compreso) all'inizio dell'interruzione.

Un timestamp nel formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
latestStartTime

string (Timestamp format)

Obbligatorio. Limite superiore (incluso) all'inizio dell'interruzione.

Un timestamp in formato "Zulu" UTC RFC3339, con risoluzione a livello di nanosecondo e fino a nove cifre frazionarie. Esempi: "2014-10-02T15:01:23Z" e "2014-10-02T15:01:23.045123456Z".
minDuration

string (Duration format)

Obbligatorio. Durata minima della pausa. Deve essere positivo.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".

FrequencyConstraint

È possibile limitare ulteriormente la frequenza e la durata delle interruzioni specificate sopra, imponendo una frequenza minima delle interruzioni, ad esempio "Deve esserci un'interruzione di almeno 1 ora ogni 12 ore". Supponendo che questo possa essere interpretato come "In qualsiasi finestra temporale scorrevole di 12 ore, deve esserci almeno una pausa di almeno un'ora", questo esempio si tradurrebbe nel seguente FrequencyConstraint:

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

I tempi e la durata delle interruzioni nella soluzione rispetteranno tutti questi vincoli, oltre alle finestre temporali e alle durate minime già specificate in BreakRequest.

In pratica, un FrequencyConstraint può essere applicato alle interruzioni non consecutive. Ad esempio, la programmazione seguente rispetta l'esempio "1 h ogni 12 h":

  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
Rappresentazione JSON 
{
  "minBreakDuration": string,
  "maxInterBreakDuration": string
}
Campi
minBreakDuration

string (Duration format)

Obbligatorio. Durata minima dell'interruzione per questo vincolo. Non negativo. Vedi la descrizione di FrequencyConstraint.

Una durata in secondi con un massimo di nove cifre frazionarie, che termina con "s". Esempio: "3.5s".
maxInterBreakDuration

string (Duration format)

Obbligatorio. Periodo massimo consentito di qualsiasi intervallo di tempo nel percorso che non include almeno parzialmente un'interruzione di duration >= minBreakDuration. Deve essere positivo.

Una durata in secondi con un massimo di nove cifre frazionarie, che termina con "s". Esempio: "3.5s".

DurationDistanceMatrix

Specifica una matrice di durata e distanza tra le posizioni delle visite e di partenza dei veicoli da visitare e le località di fine dei veicoli.

Rappresentazione JSON 
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
Campi
rows[]

object (Row)

Specifica le righe della durata e della matrice della distanza. Deve contenere lo stesso numero di elementi di ShipmentModel.duration_distance_matrix_src_tags.
vehicleStartTag

string

Tag che definisce a quali veicoli si applica la durata e la matrice della distanza. Se vuoto, questo vale per tutti i veicoli e può essere presente una sola matrice.

L'inizio di ogni veicolo deve corrispondere esattamente a una matrice, ovvero a uno dei campi startTags deve corrispondere esattamente al valore vehicleStartTag di una matrice (e solo di quella matrice).

Tutte le matrici devono avere un vehicleStartTag diverso.

Riga

Specifica una riga della durata e della matrice della distanza.

Rappresentazione JSON 
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
Campi
durations[]

string (Duration format)

Valori di durata per una determinata riga. Deve avere un numero di elementi pari a ShipmentModel.duration_distance_matrix_dst_tags.

Una durata in secondi con un massimo di nove cifre frazionarie, che termina con "s". Esempio: "3.5s".
meters[]

number

Valori di distanza per una determinata riga. Se nel modello non sono presenti costi o vincoli che fanno riferimento alle distanze, questo campo può essere lasciato vuoto; in caso contrario, deve contenere lo stesso numero di elementi di durations.

TransitionAttributes

Specifica gli attributi delle transizioni tra due visite consecutive su un percorso. Alla stessa transizione possono essere applicati diversi TransitionAttributes: in questo caso, tutti i costi aggiuntivi vengono sommati e viene applicato il vincolo o il limite più rigido (secondo la semantica "AND" naturale).

Rappresentazione JSON 
{
  "srcTag": string,
  "excludedSrcTag": string,
  "dstTag": string,
  "excludedDstTag": string,
  "cost": number,
  "costPerKilometer": number,
  "distanceLimit": {
    object (DistanceLimit)
  },
  "delay": string
}
Campi
srcTag

string

Tag che definiscono l'insieme di transizioni (src->dst) a cui si applicano questi attributi.

Una visita della sorgente o l'inizio di un veicolo corrisponde a se il suo VisitRequest.tags o Vehicle.start_tags contiene srcTag o non contiene excludedSrcTag (a seconda di quale di questi due campi non è vuoto).
excludedSrcTag

string

Leggi i srcTag. Uno dei due valori srcTag e excludedSrcTag non deve essere vuoto.
dstTag

string

Una visita di destinazione o una fine del veicolo corrisponde se la sua VisitRequest.tags o Vehicle.end_tags contiene dstTag o non contiene excludedDstTag (a seconda di quale di questi due campi non è vuoto).
excludedDstTag

string

Leggi i dstTag. Uno dei due valori dstTag e excludedDstTag non deve essere vuoto.
cost

number

Specifica un costo per l'esecuzione di questa transizione. Si tratta della stessa unità di misura di tutti gli altri costi del modello e non deve essere negativo. Viene applicato in aggiunta a tutti gli altri costi esistenti.
costPerKilometer

number

Specifica un costo per chilometro applicato alla distanza percorsa durante l'esecuzione di questa transizione. Si somma a qualsiasi Vehicle.cost_per_kilometer specificato sui veicoli.
distanceLimit

object (DistanceLimit)

Specifica un limite alla distanza percorsa durante l'esecuzione di questa transizione.

A partire dal 2021/06, sono supportati solo i limiti software.
delay

string (Duration format)

Specifica un ritardo durante l'esecuzione di questa transizione.

Questo ritardo si verifica sempre dopo il completamento della visita di origine e prima dell'inizio della visita di destinazione.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".

ShipmentTypeIncompatibility

Specifica le incompatibilità tra le spedizioni a seconda del relativo tipo di spedizione. La comparsa di spedizioni incompatibili sullo stesso percorso è limitata in base alla modalità di incompatibilità.

Rappresentazione JSON 
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
Campi
types[]

string

Elenco di tipi incompatibili. Due spedizioni con shipment_types diversi tra quelli elencati sono "incompatibili".
incompatibilityMode

enum (IncompatibilityMode)

Modalità applicata all'incompatibilità.

IncompatibilityMode

Modalità che definiscono le limitazioni di visualizzazione di spedizioni incompatibili sullo stesso percorso.

Enum
INCOMPATIBILITY_MODE_UNSPECIFIED Modalità di incompatibilità non specificata. Questo valore non deve mai essere utilizzato.
NOT_PERFORMED_BY_SAME_VEHICLE In questa modalità, due spedizioni con tipi incompatibili non possono mai condividere lo stesso veicolo.
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

Per due importazioni con tipi incompatibili con la modalità di incompatibilità NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY:

  • Se entrambi sono solo per il ritiro (senza consegne) o solo per le consegne (senza ritiri), non possono condividere lo stesso veicolo.
  • Se una delle spedizioni prevede la consegna e l'altra il ritiro, le due spedizioni possono condividere lo stesso veicolo se la prima viene consegnata prima che la seconda venga ritirata.

ShipmentTypeRequirement

Specifica i requisiti tra una spedizione in base all'attributo billingType. Le specifiche dei requisiti sono definite dalla modalità dei requisiti.

Rappresentazione JSON 
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
Campi
requiredShipmentTypeAlternatives[]

string

Elenco dei tipi di spedizione alternativi richiesti dal dependentShipmentTypes.
dependentShipmentTypes[]

string

Tutte le spedizioni con un tipo nel campo dependentShipmentTypes richiedono che venga visitata almeno una spedizione di tipo requiredShipmentTypeAlternatives nello stesso percorso.

NOTA: non sono consentite catene di requisiti in cui un shipmentType dipende da sé stesso.
requirementMode

enum (RequirementMode)

Modalità applicata al requisito.

RequirementMode

Modalità che definiscono l'aspetto di spedizioni dipendenti su un itinerario.

Enum
REQUIREMENT_MODE_UNSPECIFIED Modalità requisito non specificata. Questo valore non deve mai essere utilizzato.
PERFORMED_BY_SAME_VEHICLE In questa modalità, tutte le spedizioni "dipendenti" devono condividere lo stesso veicolo di almeno una delle spedizioni "obbligatorie".
IN_SAME_VEHICLE_AT_PICKUP_TIME

Con la modalità IN_SAME_VEHICLE_AT_PICKUP_TIME, tutte le spedizioni "dipendenti" devono avere almeno una spedizione "obbligatoria" del proprio veicolo al momento del ritiro.

Di conseguenza, il ritiro di una spedizione "dipendente" deve avere:

  • Una spedizione "obbligatoria" solo per la consegna consegnata sul percorso dopo,
  • Una spedizione "obbligatoria" ritirata lungo il percorso precedente e, se la spedizione "obbligatoria" prevede una consegna, la consegna deve essere effettuata dopo il ritiro della spedizione "dipendente".
IN_SAME_VEHICLE_AT_DELIVERY_TIME Come prima, tranne che le spedizioni "dipendenti" devono avere una spedizione "obbligatoria" sul veicolo al momento della consegna.

PrecedenceRule

Una regola di precedenza tra due eventi (ogni evento rappresenta il ritiro o la consegna di una spedizione): il "secondo" evento deve iniziare almeno offsetDuration dopo l'inizio del "primo".

Più precedenze possono fare riferimento agli stessi eventi (o correlati), ad esempio "Il ritiro di B avviene dopo la consegna di A" e "il ritiro di C avviene dopo il ritiro di B".

Inoltre, le precedenze si applicano solo quando vengono eseguite entrambe le importazioni e vengono ignorate in caso contrario.

Rappresentazione JSON 
{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}
Campi
firstIsDelivery

boolean

Indica se il "primo" evento è una pubblicazione.
secondIsDelivery

boolean

Indica se il "secondo" evento è una pubblicazione.
offsetDuration

string (Duration format)

L'offset tra il "primo" e il "secondo" evento. Può essere negativo.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".
firstIndex

integer

Indice di spedizione dell'evento "primo". Questo campo è obbligatorio.
secondIndex

integer

Indice di spedizione del "secondo" evento. Questo campo deve essere specificato.