Il percorso di un veicolo può essere scomposto lungo l'asse temporale, in questo modo (presupponiamo che siano state effettuate n visite):
| | | | | T[2], | | |
| Transition | Visit #0 | | | V[2], | | |
| #0 | aka | T[1] | V[1] | ... | V[n-1] | T[n] |
| aka T[0] | V[0] | | | V[n-2],| | |
| | | | | T[n-1] | | |
^ ^ ^ ^ ^ ^ ^ ^
vehicle V[0].start V[0].end V[1]. V[1]. V[n]. V[n]. vehicle
start (arrival) (departure) start end start end end
Tieni presente che facciamo differenza tra:
- "eventi puntuali", come l'inizio e la fine del veicolo e l'inizio e la fine di ogni visita (ovvero arrivo e partenza). Si verificano in un determinato secondo.
- "intervalli di tempo", come le visite stesse e la transizione tra le visite. Anche se a volte gli intervalli di tempo possono avere una durata pari a zero, ovvero iniziare e terminare allo stesso secondo, spesso hanno una durata positiva.
Invarianti:
- Se ci sono n visite, sono presenti n + 1 transizioni.
- Una visita è sempre circondata da una transizione prima di questa (stesso indice) e da una transizione successiva (indice + 1).
- L'avvio del veicolo è sempre seguito dalla transizione n. 0.
- La fine del veicolo è sempre preceduta dalla transizione #n.
Aumentando lo zoom, ecco cosa succede durante Transition e Visit:
---+-------------------------------------+-----------------------------+-->
| TRANSITION[i] | VISIT[i] |
| | |
| * TRAVEL: the vehicle moves from | PERFORM the visit: |
| VISIT[i-1].departure_location to | |
| VISIT[i].arrival_location, which | * Spend some time: |
| takes a given travel duration | the "visit duration". |
| and distance | |
| | * Load or unload |
| * BREAKS: the driver may have | some quantities from the |
| breaks (e.g. lunch break). | vehicle: the "demand". |
| | |
| * WAIT: the driver/vehicle does | |
| nothing. This can happen for | |
| many reasons, for example when | |
| the vehicle reaches the next | |
| event's destination before the | |
| start of its time window | |
| | |
| * DELAY: *right before* the next | |
| arrival. E.g. the vehicle and/or | |
| driver spends time unloading. | |
| | |
---+-------------------------------------+-----------------------------+-->
^ ^ ^
V[i-1].end V[i].start V[i].end
Infine, ecco come possono essere organizzati VIAGGI, PAUSA, RITARDO e ATTESA durante una transizione.
- Non si sovrappongono.
- Il ritardo è univoco e deve essere un periodo di tempo contiguo subito prima della prossima visita (o della fine del veicolo). Pertanto, è sufficiente conoscere la durata del ritardo per conoscere l'ora di inizio e di fine.
- I BREAKS sono periodi di tempo contigui e non sovrapposti. La risposta specifica l'ora di inizio e la durata di ogni interruzione.
- VIAGGI e ATTESA sono "prerilasciabili": possono essere interrotti più volte durante questa transizione. I clienti possono presumere che il viaggio avvenga "il prima possibile" e che l'"attesa" riempia il tempo rimanente.
Esempio (complesso):
TRANSITION[i]
--++-----+-----------------------------------------------------------++-->
|| | | | | | | ||
|| T | B | T | | B | | D ||
|| r | r | r | W | r | W | e ||
|| a | e | a | a | e | a | l ||
|| v | a | v | i | a | i | a ||
|| e | k | e | t | k | t | y ||
|| l | | l | | | | ||
|| | | | | | | ||
--++-----------------------------------------------------------------++-->
| Rappresentazione JSON |
|---|
{ "vehicleIndex": integer, "vehicleLabel": string, "vehicleStartTime": string, "vehicleEndTime": string, "visits": [ { object ( |
| Campi | |
|---|---|
vehicleIndex |
Veicolo che esegue il percorso, identificato dal proprio indice nell'origine |
vehicleLabel |
Etichetta del veicolo che sta effettuando questo percorso, uguale a |
vehicleStartTime |
L'ora in cui il veicolo inizia il percorso. Un timestamp in formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
vehicleEndTime |
L'ora in cui il veicolo termina il percorso. Un timestamp in formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
visits[] |
Sequenza ordinata di visite che rappresenta un itinerario. Visit[i] è la i-esima visita nel percorso. Se questo campo è vuoto, il veicolo è considerato inutilizzato. |
transitions[] |
Elenco ordinato di transizioni per il percorso. |
hasTrafficInfeasibilities |
Se L'arrivo a next_visit avverrà probabilmente dopo l'attuale finestra temporale a causa dell'aumento della stima del tempo di percorrenza ( |
routePolyline |
La rappresentazione della polilinea codificata della route. Questo campo viene compilato solo se |
breaks[] |
Soste programmate per il veicolo che sta effettuando questo percorso. La sequenza |
metrics |
Metriche relative a durata, distanza e carico per questo percorso. I campi di |
routeCosts |
Costo del percorso suddiviso in base ai campi di richiesta correlati al costo. Le chiavi sono percorsi di protocollo, relative all'input OptimizeToursRequest, ad esempio "model.shipments.pickups.cost", e i valori sono il costo totale generato dal campo del costo corrispondente, aggregato per l'intero percorso. In altre parole, i costi["model.shipments.pickups.cost"] sono la somma di tutti i costi di ritiro lungo il percorso. Tutti i costi definiti nel modello sono riportati in dettaglio qui, ad eccezione dei costi relativi a TransizioneAttributes che sono riportati solo in modo aggregato a partire dal 1° gennaio 2022. Un oggetto contenente un elenco di |
routeTotalCost |
Costo totale del percorso. La somma di tutti i costi nella mappa dei costi. |
Visita
Una visita eseguita durante un percorso. Questa visita corrisponde a un ritiro o una consegna di Shipment.
| Rappresentazione JSON |
|---|
{
"shipmentIndex": integer,
"isPickup": boolean,
"visitRequestIndex": integer,
"startTime": string,
"loadDemands": {
string: {
object ( |
| Campi | |
|---|---|
shipmentIndex |
Indice del campo |
isPickup |
Se il valore è true, la visita corrisponde al ritiro di un |
visitRequestIndex |
Indice di |
startTime |
Ora in cui inizia la visita. Tieni presente che il veicolo potrebbe arrivare prima di questo orario nel luogo in cui ti trovi. Gli orari sono coerenti con il Un timestamp in formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
loadDemands |
Domanda del carico totale delle visite come somma della spedizione e della richiesta di visita Un oggetto contenente un elenco di |
detour |
Tempo di deviazione aggiuntivo dovuto alle spedizioni visitate lungo il percorso prima della visita e al potenziale tempo di attesa generato dalle finestre temporali. Se la visita è una consegna, la deviazione viene calcolata in base alla visita di ritiro corrispondente ed è pari a: In caso contrario, viene calcolato dal veicolo Una durata in secondi con un massimo di nove cifre frazionarie, che termina con " |
shipmentLabel |
Copia del valore |
visitLabel |
Copia del valore |
Transizioni
Transizione tra due eventi lungo il percorso. Vedi la descrizione di ShipmentRoute.
Se il veicolo non dispone di un startLocation e/o endLocation, le metriche di viaggio corrispondenti sono 0.
| Rappresentazione JSON |
|---|
{ "travelDuration": string, "travelDistanceMeters": number, "trafficInfoUnavailable": boolean, "delayDuration": string, "breakDuration": string, "waitDuration": string, "totalDuration": string, "startTime": string, "routePolyline": { object ( |
| Campi | |
|---|---|
travelDuration |
Durata del viaggio durante questa transizione. Una durata in secondi con un massimo di nove cifre frazionarie, che termina con " |
travelDistanceMeters |
Distanza percorsa durante la transizione. |
trafficInfoUnavailable |
Quando il traffico viene richiesto tramite |
delayDuration |
Somma delle durate del ritardo applicate a questa transizione. Se presente, il ritardo inizia esattamente Una durata in secondi con un massimo di nove cifre frazionarie, che termina con " |
breakDuration |
Somma dell'eventuale durata delle interruzioni che si sono verificate durante questa transizione. I dettagli relativi all'ora di inizio e alla durata di ogni interruzione vengono archiviati in Una durata in secondi con un massimo di nove cifre frazionarie, che termina con " |
waitDuration |
Tempo di attesa durante questa transizione. La durata di attesa corrisponde al tempo di inattività e non include il tempo di interruzione. Tieni inoltre presente che questo tempo di attesa può essere suddiviso in più intervalli non contigui. Una durata in secondi con un massimo di nove cifre frazionarie, che termina con " |
totalDuration |
Durata totale della transizione, fornita per praticità. Questo equivale a:
Una durata in secondi con un massimo di nove cifre frazionarie, che termina con " |
startTime |
Ora di inizio di questa transizione. Un timestamp in formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
routePolyline |
La rappresentazione codificata della polilinea seguita durante la transizione. Questo campo viene compilato solo se |
vehicleLoads |
Carichi dei veicoli durante questa transizione, per ogni tipo presente nel I carichi durante la prima transizione corrispondono ai carichi di partenza del percorso del veicolo. Quindi, dopo ogni visita, i Un oggetto contenente un elenco di |
EncodedPolyline
La rappresentazione codificata di una polilinea. Ulteriori informazioni sulla codifica delle poliline sono disponibili qui: https://developers.google.com/maps/documentation/utilities/polylinealgorithm https://developers.google.com/maps/documentation/javascript/reference/geometry#encoding.
| Rappresentazione JSON |
|---|
{ "points": string } |
| Campi | |
|---|---|
points |
Stringa che rappresenta i punti codificati della polilinea. |
Pausa
Dati che rappresentano l'esecuzione di un'interruzione.
| Rappresentazione JSON |
|---|
{ "startTime": string, "duration": string } |
| Campi | |
|---|---|
startTime |
Ora di inizio di una pausa. Un timestamp in formato "Zulu" RFC3339 UTC, con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
duration |
Durata di una pausa. Una durata in secondi con un massimo di nove cifre frazionarie, che termina con " |