Il percorso di un veicolo può essere scomposto lungo l'asse del tempo, in questo modo (supponiamo che ci siano 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
Facciamo la differenza tra:
- "eventi puntuali", come l'inizio e la fine del veicolo e l'inizio e la fine di ogni visita (ovvero l'arrivo e la partenza). Si verificano in un dato secondo.
- "intervalli di tempo", come le visite stesse e la transizione tra una visita e l'altra. Anche se a volte gli intervalli di tempo possono avere una durata pari a zero, ovvero inizio e fine 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 precedente (stesso indice) e da una transizione successiva (indice + 1).
- L'avvio del veicolo è sempre seguito dal passaggio 0.
- La fine del veicolo è sempre preceduta dalla transizione #n.
Aumentando lo zoom, ecco cosa succede durante un Transition e un 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 si può organizzare VIAGGI, PAUSE, 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.
- Le interruzioni sono periodi di tempo contigui e non sovrapposti. La risposta specifica l'ora di inizio e la durata di ogni interruzione.
- TRAVEL e WAIT sono "prerilasciabili": possono essere interrotti più volte durante questa transizione. I clienti possono presumere che il viaggio avvenga "il prima possibile" e "attendi" esaurisce 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 suo indice nella sorgente |
vehicleLabel |
Etichetta del veicolo che effettua questo percorso, uguale a |
vehicleStartTime |
L'ora in cui il veicolo inizia il percorso. Un timestamp nel formato RFC3339 UTC "Zulu" con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
vehicleEndTime |
L'ora in cui il veicolo termina il percorso. Un timestamp nel formato RFC3339 UTC "Zulu" con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
visits[] |
Sequenza ordinata di visite che rappresenta un percorso. visite[i] indica l'i-esima visita nel percorso. Se questo campo è vuoto, il veicolo è considerato inutilizzato. |
transitions[] |
Elenco ordinato di transizioni per il percorso. |
hasTrafficInfeasibilities |
Se il criterio L'arrivo alla prossima visita probabilmente avverrà dopo la finestra temporale attuale a causa dell'aumento della stima del tempo di percorrenza |
routePolyline |
La rappresentazione codificata della polilinea della route. Questo campo viene compilato solo se il criterio |
breaks[] |
Pause programmate per il veicolo che effettua 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 ai costi. Le chiavi sono percorsi di protocollo, rispetto all'input OptimizeToursRequest, ad esempio "model.shipments.pickups.cost" e i valori corrispondono al costo totale generato dal campo di costo corrispondente, aggregato per l'intero percorso. In altre parole, costi ["model.shipments.pickups.cost"] è 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 TransitionAttributes che sono riportati solo in modo aggregato a partire dal 2022/01. Un oggetto contenente un elenco di |
routeTotalCost |
Costo totale del percorso. La somma di tutti i costi nella mappa dei costi. |
Visita
Una visita effettuata durante un percorso. Questa visita corrisponde a un ritiro o una consegna di un Shipment.
| Rappresentazione JSON |
|---|
{
"shipmentIndex": integer,
"isPickup": boolean,
"visitRequestIndex": integer,
"startTime": string,
"loadDemands": {
string: {
object ( |
| Campi | |
|---|---|
shipmentIndex |
Indice del campo |
isPickup |
Se true, la visita corrisponde al ritiro di un |
visitRequestIndex |
Indice di |
startTime |
L'ora in cui ha inizio la visita. Tieni presente che il veicolo potrebbe arrivare prima di questo nel luogo in cui ti trovi. Gli orari sono in linea con l' Un timestamp nel formato RFC3339 UTC "Zulu" con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
loadDemands |
Domanda totale di caricamento di visite come somma della spedizione e della richiesta di visita Un oggetto contenente un elenco di |
detour |
Tempo di deviazione extra dovuto alle spedizioni visitate sul percorso prima della visita e ai potenziali tempi di attesa causati da finestre temporali. Se la visita è una consegna, la deviazione viene calcolata in base alla visita di ritiro corrispondente ed è uguale a: In caso contrario, viene calcolato dal veicolo Durata in secondi con un massimo di nove cifre frazionarie e termina con " |
shipmentLabel |
Copia del valore |
visitLabel |
Copia del valore |
Transizione
Transizione tra due eventi lungo il percorso. Vedi la descrizione di ShipmentRoute.
Se il veicolo non dispone di 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. Durata in secondi con un massimo di nove cifre frazionarie e termina con " |
travelDistanceMeters |
Distanza percorsa durante la transizione. |
trafficInfoUnavailable |
Se il traffico viene richiesto tramite |
delayDuration |
Somma delle durate del ritardo applicate a questa transizione. Se presente, il ritardo inizia esattamente Durata in secondi con un massimo di nove cifre frazionarie e termina con " |
breakDuration |
Somma della durata delle pause durante questa transizione, se presente. I dettagli relativi all'ora di inizio e alla durata di ogni interruzione vengono memorizzati in Durata in secondi con un massimo di nove cifre frazionarie e termina con " |
waitDuration |
Tempo di attesa durante questa transizione. La durata di attesa corrisponde al tempo di inattività e non include il tempo di pausa. Tieni inoltre presente che questo tempo di attesa può essere suddiviso in diversi intervalli non contigui. Durata in secondi con un massimo di nove cifre frazionarie e termina con " |
totalDuration |
Durata totale della transizione, fornita per praticità. È uguale a:
Durata in secondi con un massimo di nove cifre frazionarie e termina con " |
startTime |
Ora di inizio di questa transizione. Un timestamp nel formato RFC3339 UTC "Zulu" con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
routePolyline |
La rappresentazione codificata della polilinea del percorso seguito durante la transizione. Questo campo viene compilato solo se il criterio |
vehicleLoads |
Durante questa transizione vengono caricati i veicoli, per ogni tipo presente nell' I carichi durante la prima transizione sono i carichi di partenza del percorso del veicolo. Poi, dopo ogni visita, i Un oggetto contenente un elenco di |
EncodedPolyline
La rappresentazione codificata di una polilinea. Ulteriori informazioni sulla codifica delle polilinee 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 nel formato RFC3339 UTC "Zulu" con risoluzione in nanosecondi e fino a nove cifre frazionarie. Esempi: |
duration |
Durata di una pausa. Durata in secondi con un massimo di nove cifre frazionarie e termina con " |