ShipmentRoute

Il percorso di un veicolo può essere decomposto, lungo l'asse del tempo, come segue (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

Tieni presente che facciamo una distinzione tra:

  • "Eventi puntuali", come l'inizio e la fine del servizio e l'inizio e la fine di ogni visita (ovvero arrivo e partenza). Avvengono in un determinato secondo.
  • "intervalli di tempo", come le visite stesse e la transizione tra le visite. Sebbene a volte gli intervalli di tempo possano avere una durata pari a zero, ovvero iniziare e terminare nello stesso secondo, spesso hanno una durata positiva.

Invariati:

  • Se ci sono n visite, ci sono n+1 transizioni.
  • Una visita è sempre preceduta da una transizione (stessa riga) e seguita da un'altra transizione (riga + 1).
  • L'avvio del veicolo è sempre seguito dalla transizione 0.
  • La fine del veicolo è sempre preceduta dalla transizione n.

Se aumenti 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 TRAVEL, BREAKS, DELAY e WAIT possono essere disposti durante una transizione.

  • Non si sovrappongono.
  • DELAY è univoco e deve essere un periodo di tempo contiguo immediatamente prima della visita successiva (o della fine del servizio del veicolo). Pertanto, è sufficiente conoscere la durata del ritardo per conoscere la relativa 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 "preemptable": 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.

Un 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 (Visit)
    }
  ],
  "transitions": [
    {
      object (Transition)
    }
  ],
  "hasTrafficInfeasibilities": boolean,
  "routePolyline": {
    object (EncodedPolyline)
  },
  "breaks": [
    {
      object (Break)
    }
  ],
  "metrics": {
    object (AggregatedMetrics)
  },
  "routeCosts": {
    string: number,
    ...
  },
  "routeTotalCost": number
}
Campi
vehicleIndex

integer

Veicolo che esegue il percorso, identificato dal relativo indice nell'origine ShipmentModel.
vehicleLabel

string

Etichetta del veicolo che esegue questo percorso, uguale a ShipmentModel.vehicles(vehicleIndex).label, se specificato.
vehicleStartTime

string (Timestamp format)

Ora in cui il veicolo inizia il percorso.

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".
vehicleEndTime

string (Timestamp format)

Ora in cui il veicolo termina il percorso.

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".
visits[]

object (Visit)

Sequenza ordinata di visite che rappresenta un percorso. visits[i] è la i-esima visita nel percorso. Se questo campo è vuoto, il veicolo è considerato inutilizzato.
transitions[]

object (Transition)

Elenco ordinato delle transizioni per il percorso.
hasTrafficInfeasibilities

boolean

Quando OptimizeToursRequest.consider_road_traffic è impostato su true, questo campo indica che le incongruenze nei tempi di percorrenza del percorso vengono previste utilizzando le stime della durata del viaggio in base al traffico. Il tempo potrebbe non essere sufficiente per completare i viaggi, i ritardi e le interruzioni tra le visite, prima della prima visita o dopo l'ultima visita, tenendo conto del traffico, pur rispettando le finestre di tempo per le visite e i veicoli. Ad esempio,

  startTime(previous_visit) + duration(previous_visit) +
  travelDuration(previous_visit, next_visit) > startTime(next_visit)

L'arrivo a next_visit avverrà probabilmente più tardi rispetto all'attuale finestra temporale a causa dell'aumento della stima del tempo di percorrenza travelDuration(previous_visit, next_visit) a causa del traffico. Inoltre, una pausa potrebbe sovrapporsi a una visita a causa di un aumento delle stime dei tempi di percorrenza e delle limitazioni relative alle finestre di tempo per le visite o le pause.
routePolyline

object (EncodedPolyline)

La rappresentazione polilinea codificata del percorso. Questo campo viene compilato solo se OptimizeToursRequest.populate_polylines è impostato su true.
breaks[]

object (Break)

Soste programmate per il veicolo che esegue questo percorso. La sequenza breaks rappresenta intervalli di tempo, ognuno dei quali inizia al startTime corrispondente e dura duration secondi.
metrics

object (AggregatedMetrics)

Metriche relative a durata, distanza e carico per questo percorso. I campi di AggregatedMetrics vengono sommati su tutti i ShipmentRoute.transitions o ShipmentRoute.visits, a seconda del contesto.
routeCosts

map (key: string, value: number)

Costo del percorso, suddiviso per campi di richiesta relativi al costo. Le chiavi sono percorsi proto, relativi all'input OptimizeToursRequest, ad esempio "model.shipments.pickups.cost", e i valori sono il costo totale generato dal campo del costo corrispondente, aggregato nell'intero percorso. In altre parole, costs["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 vengono riportati solo in modo aggregato a partire da gennaio 2022.
routeTotalCost

number

Costo totale del percorso. La somma di tutti i costi nella mappa dei costi.

Visita

Una visita effettuata durante un percorso. Questa visita corrisponde al ritiro o alla consegna di un Shipment.

Rappresentazione JSON 
{
  "shipmentIndex": integer,
  "isPickup": boolean,
  "visitRequestIndex": integer,
  "startTime": string,
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "detour": string,
  "shipmentLabel": string,
  "visitLabel": string
}
Campi
shipmentIndex

integer

Indice del campo shipments nell'origine ShipmentModel.
isPickup

boolean

Se true, la visita corrisponde al ritiro di un Shipment. In caso contrario, corrisponde a un caricamento.
visitRequestIndex

integer

Indice di VisitRequest nel campo Ritiro o Consegna del Shipment (vedi isPickup).
startTime

string (Timestamp format)

Ora di inizio della visita. Tieni presente che il veicolo potrebbe arrivare prima di questa data e ora presso la sede della visita. Gli orari sono in linea con le ShipmentModel.

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".
loadDemands

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

Domanda di carico delle visite totale come somma della spedizione e della richiesta di visita loadDemands. I valori sono negativi se la visita è una pubblicazione. Le richieste vengono registrate per gli stessi tipi di Transition.loads (vedi questo campo).
detour

string (Duration format)

Tempo aggiuntivo per i giri a vuoto dovuti alle spedizioni visitate sul percorso prima della visita e al potenziale tempo di attesa indotto dalle finestre temporali. Se la visita è una consegna, il percorso alternativo viene calcolato dalla visita di ritiro corrispondente ed è uguale a:

startTime(delivery) - startTime(pickup)
- (duration(pickup) + travel duration from the pickup location
to the delivery location).

In caso contrario, viene calcolato dal veicolo startLocation ed è uguale a:

startTime - vehicleStartTime - travel duration from
the vehicle's `startLocation` to the visit.

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

string

Copia del Shipment.label corrispondente, se specificato nel Shipment.
visitLabel

string

Copia del VisitRequest.label corrispondente, se specificato nel VisitRequest.

Transizione

Transizione tra due eventi sul percorso. Consulta la descrizione di ShipmentRoute.

Se il veicolo non ha startLocation e/o endLocation, le metriche relative ai viaggi corrispondenti sono pari a 0.

Rappresentazione JSON 
{
  "travelDuration": string,
  "travelDistanceMeters": number,
  "trafficInfoUnavailable": boolean,
  "delayDuration": string,
  "breakDuration": string,
  "waitDuration": string,
  "totalDuration": string,
  "startTime": string,
  "routePolyline": {
    object (EncodedPolyline)
  },
  "routeToken": string,
  "vehicleLoads": {
    string: {
      object (VehicleLoad)
    },
    ...
  }
}
Campi
travelDuration

string (Duration format)

Durata del viaggio durante questa transizione.

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

number

Distanza percorsa durante la transizione.
trafficInfoUnavailable

boolean

Quando il traffico viene richiesto tramite OptimizeToursRequest.consider_road_traffic e non è stato possibile recuperare le informazioni sul traffico per un Transition, questo valore booleano viene impostato su true. Potrebbe trattarsi di un problema temporaneo (un raro problema nei server del traffico in tempo reale) o permanente (nessun dato per questa località).
delayDuration

string (Duration format)

Somma delle durate dei ritardi applicati a questa transizione. Se presente, il ritardo inizia esattamente delayDuration secondi prima dell'evento successivo (fine della visita o del veicolo). Leggi i TransitionAttributes.delay.

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

string (Duration format)

Somma della durata delle interruzioni, se presenti, che si verificano durante questa transizione. I dettagli sull'ora di inizio e sulla durata di ogni pausa vengono memorizzati in ShipmentRoute.breaks.

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

string (Duration format)

Tempo di attesa durante questa transizione. La durata dell'attesa corrisponde al tempo di inattività e non include la pausa. 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 "s". Esempio: "3.5s".
totalDuration

string (Duration format)

Durata totale della transizione, fornita per praticità. È uguale a:

  • prossima visita startTime (o vehicleEndTime se si tratta dell'ultima transizione) - startTime di questa transizione;
  • Se ShipmentRoute.has_traffic_infeasibilities è falso, vale anche quanto segue: "totalDuration = travelDuration + delayDuration
  • breakDuration + waitDuration`.

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

string (Timestamp format)

Ora di inizio di questa transizione.

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".
routePolyline

object (EncodedPolyline)

La rappresentazione polilinea codificata del percorso seguito durante la transizione. Questo campo viene compilato solo se populateTransitionPolylines è impostato su true.
routeToken

string

Solo output. Un token opaco che può essere passato all'SDK Navigation per ricostruire il percorso durante la navigazione e, in caso di deviazione, rispettare l'intenzione originale al momento della creazione del percorso. Tratta questo token come un blob opaco. Non confrontare il valore tra le richieste, in quanto potrebbe cambiare anche se il servizio restituisce lo stesso percorso esatto. Questo campo viene compilato solo se populateTransitionPolylines è impostato su true.
vehicleLoads

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

Carichi del veicolo durante questa transizione, per ogni tipo che compare in Vehicle.load_limits di questo veicolo o che ha Shipment.load_demands diverso da zero in alcune spedizioni eseguite su questo percorso.

I carichi durante la prima transizione sono i carichi iniziali del percorso del veicolo. Dopo ogni visita, i valori loadDemands vengono aggiunti o sottratti per ottenere i carichi della transizione successiva, a seconda che la visita sia stata un ritiro o una consegna.

EncodedPolyline

La rappresentazione codificata di una polilinea. Puoi trovare ulteriori informazioni sulla codifica dei polilinee 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

string

Stringa che rappresenta i punti codificati del polilinea.

Pausa

Dati che rappresentano l'esecuzione di un'interruzione.

Rappresentazione JSON 
{
  "startTime": string,
  "duration": string
}
Campi
startTime

string (Timestamp format)

Ora di inizio di un'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".
duration

string (Duration format)

Durata di una pausa.

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