Indice
RouteOptimization(interfaccia)AggregatedMetrics(messaggio)BatchOptimizeToursMetadata(messaggio)BatchOptimizeToursRequest(messaggio)BatchOptimizeToursRequest.AsyncModelConfig(messaggio)BatchOptimizeToursResponse(messaggio)BreakRule(messaggio)BreakRule.BreakRequest(messaggio)BreakRule.FrequencyConstraint(messaggio)DataFormat(enum)DistanceLimit(messaggio)GcsDestination(messaggio)GcsSource(messaggio)InjectedSolutionConstraint(messaggio)InjectedSolutionConstraint.ConstraintRelaxation(messaggio)InjectedSolutionConstraint.ConstraintRelaxation.Relaxation(messaggio)InjectedSolutionConstraint.ConstraintRelaxation.Relaxation.Level(enum)InputConfig(messaggio)Location(messaggio)OptimizeToursLongRunningMetadata(messaggio)OptimizeToursRequest(messaggio)OptimizeToursRequest.SearchMode(enum)OptimizeToursRequest.SolvingMode(enum)OptimizeToursResponse(messaggio)OptimizeToursResponse.Metrics(messaggio)OptimizeToursUriMetadata(messaggio)OptimizeToursUriRequest(messaggio)OptimizeToursUriResponse(messaggio)OptimizeToursValidationError(messaggio)OptimizeToursValidationError.FieldReference(messaggio)OutputConfig(messaggio)RouteModifiers(messaggio)Shipment(messaggio)Shipment.Load(messaggio)Shipment.VisitRequest(messaggio)ShipmentModel(messaggio)ShipmentModel.DurationDistanceMatrix(messaggio)ShipmentModel.DurationDistanceMatrix.Row(messaggio)ShipmentModel.Objective(messaggio)ShipmentModel.Objective.Type(enum)ShipmentModel.PrecedenceRule(messaggio)ShipmentRoute(messaggio)ShipmentRoute.Break(messaggio)ShipmentRoute.EncodedPolyline(messaggio)ShipmentRoute.Transition(messaggio)ShipmentRoute.VehicleLoad(messaggio)ShipmentRoute.Visit(messaggio)ShipmentRoute.Visit.VisitType(enum)ShipmentTypeIncompatibility(messaggio)ShipmentTypeIncompatibility.IncompatibilityMode(enum)ShipmentTypeRequirement(messaggio)ShipmentTypeRequirement.RequirementMode(enum)SkippedShipment(messaggio)SkippedShipment.Reason(messaggio)SkippedShipment.Reason.Code(enum)TimeWindow(messaggio)TransitionAttributes(messaggio)Uri(messaggio)Vehicle(messaggio)Vehicle.DurationLimit(messaggio)Vehicle.LoadLimit(messaggio)Vehicle.LoadLimit.Interval(messaggio)Vehicle.LoadLimit.LoadCost(messaggio)Vehicle.TravelMode(enum)Vehicle.UnloadingPolicy(enum)VehicleFullness(messaggio)Waypoint(messaggio)
RouteOptimization
Un servizio per ottimizzare i percorsi dei veicoli.
Validità di determinati tipi di campi:
google.protobuf.Timestamp- Gli orari sono espressi in tempo Unix: secondi dal 1970-01-01T00:00:00+00:00.
- seconds deve essere compreso tra [0, 253402300799], ovvero tra [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
- nanos deve essere non impostato o impostato su 0.
google.protobuf.Duration- seconds deve essere compreso tra [0, 253402300799], ovvero tra [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
- nanos deve essere non impostato o impostato su 0.
google.type.LatLng- La latitudine deve essere compresa tra -90,0 e 90,0.
- La longitudine deve essere compresa tra -180,0 e 180,0.
- Almeno uno dei valori di latitudine e longitudine deve essere diverso da zero.
| BatchOptimizeTours |
|---|
|
Ottimizza i percorsi dei veicoli per uno o più messaggi Questo metodo è un'operazione a lunga esecuzione (LRO). Gli input per l'ottimizzazione (messaggi L'utente può eseguire il polling di Se il campo LRO Se il campo
|
| OptimizeTours |
|---|
|
Invia un Un modello L'obiettivo è fornire un'assegnazione di
|
| OptimizeToursLongRunning |
|---|
|
Questa è una variante del metodo L'oggetto
|
| OptimizeToursUri |
|---|
|
Questa è una variante del metodo Il client specifica l'URI Cloud Storage del Questo metodo deve essere preferito al metodo L'oggetto
|
AggregatedMetrics
Metriche aggregate per ShipmentRoute (risp. per OptimizeToursResponse) su tutti gli elementi Transition e/o Visit (risp. su tutti gli elementi ShipmentRoute).
| Campi | |
|---|---|
performed_shipment_count |
Numero di spedizioni eseguite. Tieni presente che una coppia di ritiro e consegna viene conteggiata una sola volta. |
travel_duration |
La durata totale del viaggio per un percorso o una soluzione. |
wait_duration |
La durata totale dell'attesa per un percorso o una soluzione. |
delay_duration |
La durata totale del ritardo per un percorso o una soluzione. |
break_duration |
La durata totale delle pause per un percorso o una soluzione. |
visit_duration |
La durata totale delle visite per un percorso o una soluzione. |
total_duration |
La durata totale deve essere uguale alla somma di tutte le durate sopra indicate. Per i percorsi, corrisponde anche a: |
travel_distance_meters |
Distanza totale di viaggio per un percorso o una soluzione. |
max_loads |
Carico massimo raggiunto sull'intero percorso (risp. soluzione), per ciascuna delle quantità su questo percorso (risp. soluzione), calcolato come il massimo su tutti i |
performed_mandatory_shipment_count |
Numero di spedizioni obbligatorie eseguite. Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
performed_shipment_penalty_cost_sum |
La somma dei Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
BatchOptimizeToursMetadata
Questo tipo non ha campi.
Metadati delle operazioni per le chiamate BatchOptimizeToursRequest.
BatchOptimizeToursRequest
Richiedi l'ottimizzazione in batch dei tour come operazione asincrona. Ogni file di input deve contenere un OptimizeToursRequest e ogni file di output conterrà un OptimizeToursResponse. La richiesta contiene informazioni per leggere/scrivere e analizzare i file. Tutti i file di input e output devono trovarsi nello stesso progetto.
| Campi | |
|---|---|
parent |
Obbligatorio. Progetto e località di destinazione per effettuare una chiamata. Formato:
I valori |
model_configs[] |
Obbligatorio. Informazioni di input/output per ogni modello di acquisto, come percorsi dei file e formati dei dati. |
AsyncModelConfig
Informazioni per risolvere un modello di ottimizzazione in modo asincrono.
| Campi | |
|---|---|
display_name |
Facoltativo. Nome del modello definito dall'utente, che può essere utilizzato come alias dagli utenti per tenere traccia dei modelli. |
input_config |
Obbligatorio. Informazioni sul modello di input. |
output_config |
Obbligatorio. Le informazioni sulla posizione di output desiderata. |
BatchOptimizeToursResponse
Questo tipo non ha campi.
Risposta a un BatchOptimizeToursRequest. Questo valore viene restituito nell'operazione a lunga esecuzione al termine dell'operazione.
BreakRule
Regole per generare pause per un veicolo (ad es. pause pranzo). Una pausa è un periodo di tempo contiguo durante il quale il veicolo rimane inattivo nella sua posizione attuale e non può eseguire alcuna visita. Un'interruzione può verificarsi:
- durante il viaggio tra due visite (che include il tempo immediatamente prima o immediatamente dopo una visita, ma non nel mezzo di una visita), nel qual caso estende il tempo di transito corrispondente tra le visite,
- o prima dell'ora di inizio del veicolo (il veicolo non può partire nel mezzo di una pausa), nel qual caso non influisce sull'ora di inizio del veicolo.
- o dopo la fine del veicolo (idem, con l'ora di fine del veicolo).
| Campi | |
|---|---|
break_requests[] |
Sequenza di interruzioni. Consulta il messaggio |
frequency_constraints[] |
Potrebbero essere applicati diversi |
BreakRequest
La sequenza delle pause (ovvero il loro numero e ordine) che si applicano a ogni veicolo deve essere nota in anticipo. I BreakRequest ripetuti definiscono la sequenza, nell'ordine in cui devono verificarsi. Le finestre temporali (earliest_start_time / latest_start_time) possono sovrapporsi, ma devono essere compatibili con l'ordine (questo viene verificato).
| Campi | |
|---|---|
earliest_start_time |
Obbligatorio. Limite inferiore (incluso) all'inizio della pausa. |
latest_start_time |
Obbligatorio. Limite superiore (incluso) per l'inizio della pausa. |
min_duration |
Obbligatorio. Durata minima dell'interruzione. Deve essere positivo. |
FrequencyConstraint
È possibile limitare ulteriormente la frequenza e la durata delle pause specificate sopra applicando una frequenza minima delle pause, ad esempio "Deve esserci una pausa di almeno 1 ora ogni 12 ore". Supponendo che ciò possa essere interpretato come "All'interno di qualsiasi finestra temporale scorrevole di 12 ore, deve esserci almeno una pausa di almeno un'ora", l'esempio si tradurrebbe nel seguente FrequencyConstraint:
{
min_break_duration { seconds: 3600 } # 1 hour.
max_inter_break_duration { seconds: 39600 } # 11 hours (12 - 1 = 11).
}
La tempistica e la durata delle pause 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 a pause non consecutive. Ad esempio, la seguente pianificazione rispetta l'esempio "1 ora ogni 12 ore":
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
| Campi | |
|---|---|
min_break_duration |
Obbligatorio. Durata minima dell'interruzione per questo vincolo. Non negativo. Visualizza la descrizione di |
max_inter_break_duration |
Obbligatorio. Durata massima consentita di qualsiasi intervallo di tempo nel percorso che non includa, almeno parzialmente, una pausa di |
DataFormat
Formati dei dati per i file di input e output.
| Enum | |
|---|---|
DATA_FORMAT_UNSPECIFIED |
Valore non valido, il formato non deve essere UNSPECIFIED. |
JSON |
JavaScript Object Notation. |
PROTO_TEXT |
Formato di testo dei buffer di protocollo. Consulta https://protobuf.dev/reference/protobuf/textformat-spec/ |
DistanceLimit
Un limite che definisce una distanza massima che può essere percorsa. Può essere rigido o morbido.
Se viene definito un limite flessibile, devono essere definiti sia soft_max_meters che cost_per_kilometer_above_soft_max e devono essere non negativi.
| Campi | |
|---|---|
max_meters |
Un limite rigido che vincola la distanza a un massimo di max_meters. Il limite deve essere non negativo. |
soft_max_meters |
Un limite flessibile non impone un limite di distanza massima, ma se viene violato comporta un costo che si aggiunge ad altri costi definiti nel modello, con la stessa unità. Se definito, soft_max_meters deve essere inferiore a max_meters e deve essere non negativo. |
cost_per_kilometer_below_soft_max |
Costo per chilometro sostenuto, fino a Questo costo non è supportato in |
cost_per_kilometer_above_soft_max |
Costo per chilometro sostenuto se la distanza supera il limite di Il costo deve essere non negativo. |
GcsDestination
La località di Google Cloud Storage in cui verranno scritti i file di output.
| Campi | |
|---|---|
uri |
Obbligatorio. URI Google Cloud Storage. |
GcsSource
La località di Google Cloud Storage da cui verrà letto il file di input.
| Campi | |
|---|---|
uri |
Obbligatorio. URI di un oggetto Google Cloud Storage con il formato |
InjectedSolutionConstraint
Soluzione inserita nella richiesta, incluse le informazioni su quali visite devono essere vincolate e come.
| Campi | |
|---|---|
routes[] |
Route della soluzione da inserire. Alcuni percorsi potrebbero essere omessi dalla soluzione originale. I percorsi e le spedizioni saltate devono soddisfare le ipotesi di validità di base elencate per |
skipped_shipments[] |
Spedizioni ignorate della soluzione da inserire. Alcuni potrebbero essere omessi dalla soluzione originale. Consulta il campo |
constraint_relaxations[] |
Per zero o più gruppi di veicoli, specifica quando e quanto allentare i vincoli. Se questo campo è vuoto, tutti i percorsi dei veicoli non vuoti sono completamente vincolati. |
ConstraintRelaxation
Per un gruppo di veicoli, specifica le soglie in base alle quali i vincoli sulle visite verranno allentati e a quale livello. Le spedizioni elencate nel campo skipped_shipment devono essere saltate, ovvero non possono essere eseguite.
| Campi | |
|---|---|
relaxations[] |
Tutti i rilassamenti dei vincoli di visita che verranno applicati alle visite sui percorsi con veicoli in |
vehicle_indices[] |
Specifica gli indici dei veicoli a cui si applica il vincolo di visita Un indice del veicolo viene mappato allo stesso modo di |
Relax
Se relaxations è vuoto, l'ora di inizio e la sequenza di tutte le visite su routes sono completamente vincolate e non è possibile inserire o aggiungere nuove visite a questi percorsi. Inoltre, l'ora di inizio e di fine di un veicolo in routes è completamente vincolata, a meno che il veicolo non sia vuoto (ovvero non abbia visite e used_if_route_is_empty sia impostato su false nel modello).
relaxations(i).level specifica il livello di rilassamento dei vincoli applicato a una visita #j che soddisfa:
route.visits(j).start_time >= relaxations(i).threshold_timeANDj + 1 >= relaxations(i).threshold_visit_count
Analogamente, l'inizio del percorso del veicolo viene posticipato a relaxations(i).level se soddisfa:
vehicle_start_time >= relaxations(i).threshold_timeANDrelaxations(i).threshold_visit_count == 0e la fine del veicolo viene impostata surelaxations(i).levelse soddisfa:vehicle_end_time >= relaxations(i).threshold_timeANDroute.visits_size() + 1 >= relaxations(i).threshold_visit_count
Per applicare un livello di rilassamento se una visita soddisfa threshold_visit_count O threshold_time, aggiungi due relaxations con lo stesso level: uno con solo threshold_visit_count impostato e l'altro con solo threshold_time impostato. Se una visita soddisfa le condizioni di più relaxations, viene applicato il livello più permissivo. Di conseguenza, dalla partenza del veicolo alle visite del percorso in ordine fino alla fine del veicolo, il livello di rilassamento diventa più rilassato, ovvero il livello di rilassamento non diminuisce man mano che il percorso procede.
La tempistica e la sequenza delle visite del percorso che non soddisfano le condizioni di soglia di un relaxations sono completamente vincolate e non è possibile inserire visite in queste sequenze. Inoltre, se l'inizio o la fine di un veicolo non soddisfano le condizioni di un allentamento, l'orario è fisso, a meno che il veicolo non sia vuoto.
| Campi | |
|---|---|
level |
Il livello di rilassamento dei vincoli che si applica quando vengono soddisfatte le condizioni a partire da |
threshold_time |
L'ora in cui o dopo la quale è possibile applicare l'allentamento |
threshold_visit_count |
Il numero di visite in corrispondenza o dopo le quali è possibile applicare l'allentamento Se è |
Livello
Esprime i diversi livelli di rilassamento dei vincoli, che vengono applicati per una visita e per quelle successive quando soddisfano le condizioni di soglia.
L'enumerazione riportata di seguito è in ordine di rilassamento crescente.
| Enum | |
|---|---|
LEVEL_UNSPECIFIED |
Livello di rilassamento predefinito implicito: non viene rilassato alcun vincolo, ovvero tutte le visite sono completamente vincolate. Questo valore non deve essere utilizzato esplicitamente in |
RELAX_VISIT_TIMES_AFTER_THRESHOLD |
Gli orari di inizio delle visite e gli orari di inizio/fine dei veicoli verranno rilassati, ma ogni visita rimane associata allo stesso veicolo e la sequenza delle visite deve essere rispettata: non è possibile inserire visite tra di loro o prima di loro. |
RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD |
Come RELAX_VISIT_TIMES_AFTER_THRESHOLD, ma anche la sequenza di visite è meno rigida: le visite possono essere eseguite solo da questo veicolo, ma potrebbero non essere eseguite. |
RELAX_ALL_AFTER_THRESHOLD |
Come RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD, ma anche il veicolo è rilassato: le visite sono completamente senza costi al momento o dopo l'orario di soglia e possono potenzialmente non essere eseguite. |
InputConfig
Specifica un input per [BatchOptimizeTours][google.maps.routeoptimization.v1.RouteOptimizationService.BatchOptimizeTours].
| Campi | |
|---|---|
data_format |
Obbligatorio. Il formato dei dati di input. |
Campo unione source. Obbligatorio. source può essere solo uno dei seguenti tipi: |
|
gcs_source |
Una località di Google Cloud Storage. Deve essere un singolo oggetto (file). |
Località
Incapsula una località (un punto geografico e un'intestazione facoltativa).
| Campi | |
|---|---|
lat_lng |
Le coordinate geografiche del waypoint. |
heading |
La direzione 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 la consegna. I valori della direzione possono essere compresi tra 0 e 360, dove 0 indica una direzione verso nord, 90 indica una direzione verso est e così via. |
OptimizeToursLongRunningMetadata
Questo tipo non ha campi.
Metadati delle operazioni per le chiamate OptimizeToursLongRunning.
OptimizeToursRequest
Richiesta da inviare a un risolutore di ottimizzazione dei tour che definisce il modello di spedizione da risolvere e i parametri di ottimizzazione.
| Campi | |
|---|---|
parent |
Obbligatorio. Progetto o località di destinazione per effettuare una chiamata. Formato:
I valori |
timeout |
Se questo timeout è impostato, il server restituisce una risposta prima che sia trascorso il periodo di timeout o che venga raggiunta la scadenza del server per le richieste sincrone, a seconda di quale evento si verifica per primo. Per le richieste asincrone, il server genererà una soluzione (se possibile) prima della scadenza del timeout. |
model |
Modello di spedizione da risolvere. |
solving_mode |
Per impostazione predefinita, la modalità di risoluzione è |
search_mode |
Modalità di ricerca utilizzata per risolvere la richiesta. |
injected_first_solution_routes[] |
Guida l'algoritmo di ottimizzazione nella ricerca di una prima soluzione simile a una soluzione precedente. Il modello viene vincolato quando viene creata la prima soluzione. Tutte le spedizioni non eseguite su un percorso vengono implicitamente ignorate nella prima soluzione, ma possono essere eseguite nelle soluzioni successive. La soluzione deve soddisfare alcune ipotesi di validità di base:
Se la soluzione inserita non è fattibile, non viene necessariamente restituito un errore di convalida, ma potrebbe essere restituito un errore che indica l'infattibilità. |
injected_solution_constraint |
Vincola l'algoritmo di ottimizzazione per trovare una soluzione finale simile a una soluzione precedente. Ad esempio, può essere utilizzato per bloccare parti di percorsi già completati o che devono essere completati, ma non devono essere modificati. Se la soluzione inserita non è fattibile, non viene necessariamente restituito un errore di convalida, ma potrebbe essere restituito un errore che indica l'infattibilità. |
refresh_details_routes[] |
Se non è vuoto, i percorsi specificati verranno aggiornati senza modificare la sequenza di visite o i tempi di percorrenza sottostanti: verranno aggiornati solo gli altri dettagli. Questo non risolve il modello. A partire da novembre 2020, questo campo compila solo le polilinee dei percorsi non vuoti e richiede che I campi Questo campo non deve essere utilizzato insieme a
|
interpret_injected_solutions_using_labels |
Se true:
Questa interpretazione si applica ai campi Se true, le etichette nelle seguenti categorie devono essere visualizzate al massimo una volta nella loro categoria:
Se un La rimozione di visite di un percorso o di interi percorsi da una soluzione inserita potrebbe avere un effetto sui vincoli impliciti, il che potrebbe portare a una modifica della soluzione, a errori di convalida o all'impossibilità di esecuzione. NOTA: il chiamante deve assicurarsi che ogni |
consider_road_traffic |
Considera la stima del traffico nel calcolo dei campi |
populate_polylines |
Se impostato su true, le polilinee verranno inserite negli elementi |
populate_transition_polylines |
Se true, le polilinee e i token di percorso verranno compilati nella risposta |
allow_large_deadline_despite_interruption_risk |
Se questo campo è impostato, la richiesta può avere una scadenza (vedi https://grpc.io/blog/deadlines) fino a 60 minuti. In caso contrario, la scadenza massima è di soli 30 minuti. Tieni presente che le richieste di lunga durata presentano un rischio di interruzione significativamente maggiore (ma comunque ridotto). |
use_geodesic_distances |
Se true, le distanze di viaggio verranno calcolate utilizzando le distanze geodetiche anziché quelle di Google Maps e i tempi di percorrenza verranno calcolati utilizzando le distanze geodetiche con una velocità definita da |
label |
Etichetta che può essere utilizzata per identificare questa richiesta, riportata in |
geodesic_meters_per_second |
Quando |
max_validation_errors |
Tronca il numero di errori di convalida restituiti. Questi errori sono in genere allegati a un payload di errore INVALID_ARGUMENT come dettaglio dell'errore BadRequest (https://cloud.google.com/apis/design/errors#error_details), a meno che solving_mode=VALIDATE_ONLY: consulta il campo |
SearchMode
Modalità che definisce il comportamento della ricerca, bilanciando la latenza con la qualità della soluzione. In tutte le modalità, viene applicata la scadenza della richiesta globale.
| Enum | |
|---|---|
SEARCH_MODE_UNSPECIFIED |
Modalità di ricerca non specificata, equivalente a RETURN_FAST. |
RETURN_FAST |
Interrompere la ricerca dopo aver trovato la prima soluzione valida. |
CONSUME_ALL_AVAILABLE_TIME |
Dedica tutto il tempo disponibile alla ricerca di soluzioni migliori. |
SolvingMode
Definisce il modo in cui il risolutore deve gestire la richiesta. In tutte le modalità tranne VALIDATE_ONLY, se la richiesta non è valida, riceverai un errore INVALID_REQUEST. Consulta max_validation_errors per limitare il numero di errori restituiti.
| Enum | |
|---|---|
DEFAULT_SOLVE |
Risolvi il modello. Gli avvisi possono essere emessi in [OptimizeToursResponse.validation_errors][google.cloud.optimization.v1.OptimizeToursResponse.validation_errors]. |
VALIDATE_ONLY |
Convalida solo il modello senza risolverlo: compila il maggior numero possibile di OptimizeToursResponse.validation_errors. |
DETECT_SOME_INFEASIBLE_SHIPMENTS |
Compila solo IMPORTANTE: non tutte le spedizioni non fattibili vengono restituite qui, ma solo quelle rilevate come non fattibili durante la pre-elaborazione. |
TRANSFORM_AND_RETURN_REQUEST |
Questa modalità funziona solo se Sperimentale: per ulteriori dettagli, consulta la pagina https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request. |
OptimizeToursResponse
Risposta dopo aver risolto un problema di ottimizzazione del percorso contenente i percorsi seguiti da ogni veicolo, le spedizioni che sono state saltate e il costo complessivo della soluzione.
| Campi | |
|---|---|
routes[] |
Percorsi calcolati per ogni veicolo; l'i-esimo percorso corrisponde all'i-esimo veicolo nel modello. |
request_label |
Copia di |
skipped_shipments[] |
L'elenco di tutte le spedizioni saltate. |
validation_errors[] |
Elenco di tutti gli errori di convalida che siamo stati in grado di rilevare in modo indipendente. Consulta la spiegazione "MULTIPLE ERRORS" per il messaggio |
processed_request |
In alcuni casi, modifichiamo la richiesta in entrata prima di risolverla, ad esempio aggiungendo i costi. Se solving_mode == TRANSFORM_AND_RETURN_REQUEST, la richiesta modificata viene restituita qui. Sperimentale: per ulteriori dettagli, consulta la pagina https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request. |
metrics |
Metriche di durata, distanza e utilizzo per questa soluzione. |
Metriche
Metriche complessive, aggregate per tutti i percorsi.
| Campi | |
|---|---|
aggregated_route_metrics |
Aggregati in base ai percorsi. Ogni metrica è la somma (o il valore massimo, per i carichi) di tutti i campi |
skipped_mandatory_shipment_count |
Numero di spedizioni obbligatorie saltate. |
used_vehicle_count |
Numero di veicoli utilizzati. Nota: se un percorso del veicolo è vuoto e |
earliest_vehicle_start_time |
L'ora di inizio più remota per un veicolo utilizzato, calcolata come il valore minimo di |
latest_vehicle_end_time |
L'ora di fine più recente per un veicolo utilizzato, calcolata come il valore massimo di |
costs |
Costo della soluzione, suddiviso per campi di richiesta relativi ai costi. Le chiavi sono percorsi proto, relativi alla richiesta OptimizeToursRequest di input, ad esempio "model.shipments.pickups.cost", e i valori sono il costo totale generato dal campo di costo corrispondente, aggregato per l'intera soluzione. In altre parole, costs["model.shipments.pickups.cost"] è la somma di tutti i costi dei ritiri nella soluzione. 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 da gennaio 2022. |
total_cost |
Costo totale della soluzione. La somma di tutti i valori nella mappa dei costi. |
OptimizeToursUriMetadata
Questo tipo non ha campi.
Metadati delle operazioni per le chiamate OptimizeToursUri.
OptimizeToursUriRequest
Una richiesta utilizzata dal metodo OptimizeToursUri.
| Campi | |
|---|---|
parent |
Obbligatorio. Progetto o località di destinazione per effettuare una chiamata. Formato:
I valori |
input |
Obbligatorio. L'URI dell'oggetto Cloud Storage contenente |
output |
Obbligatorio. L'URI dell'oggetto Cloud Storage che conterrà |
OptimizeToursUriResponse
Una risposta restituita dal metodo OptimizeToursUri.
| Campi | |
|---|---|
output |
Facoltativo. L'URI dell'oggetto Cloud Storage contenente Il |
OptimizeToursValidationError
Descrive un errore o un avviso riscontrato durante la convalida di un OptimizeToursRequest.
| Campi | |
|---|---|
code |
Un errore di convalida è definito dalla coppia ( I campi che seguono questa sezione forniscono ulteriori informazioni sull'errore. ERRORI MULTIPLI: quando sono presenti più errori, il processo di convalida tenta di restituirne diversi. Proprio come un compilatore, questo è un processo imperfetto. Alcuni errori di convalida saranno "fatali", ovvero interromperanno l'intero processo di convalida. Questo è il caso, tra gli altri, degli errori STABILITÀ: |
display_name |
Il nome visualizzato dell'errore. |
fields[] |
Un contesto di errore può coinvolgere 0, 1 (nella maggior parte dei casi) o più campi. Ad esempio, per fare riferimento al veicolo n. 4 e al primo ritiro della spedizione n. 2, puoi procedere come segue: Tieni presente, tuttavia, che la cardinalità di |
error_message |
Stringa leggibile che descrive l'errore. Esiste una mappatura 1:1 tra STABILITÀ: non stabile. Il messaggio di errore associato a un determinato |
offending_values |
Può contenere i valori dei campi. Questa opzione non è sempre disponibile. Non devi assolutamente fare affidamento su questo valore e utilizzarlo solo per il debug manuale del modello. |
FieldReference
Specifica un contesto per l'errore di convalida. Un FieldReference fa sempre riferimento a un determinato campo in questo file e segue la stessa struttura gerarchica. Ad esempio, possiamo specificare l'elemento n. 2 di start_time_windows del veicolo n. 5 utilizzando:
name: "vehicles" index: 5 sub_field { name: "end_time_windows" index: 2 }
Tuttavia, omettiamo le entità di primo livello come OptimizeToursRequest o ShipmentModel per evitare di affollare il messaggio.
| Campi | |
|---|---|
name |
Nome del campo, ad esempio "vehicles". |
sub_field |
Campo secondario nidificato in modo ricorsivo, se necessario. |
Campo unione
|
|
index |
Indice del campo se ripetuto. |
key |
Chiave se il campo è una mappa. |
OutputConfig
Specifica una destinazione per i risultati di [BatchOptimizeTours][google.maps.routeoptimization.v1.RouteOptimizationService.BatchOptimizeTours].
| Campi | |
|---|---|
data_format |
Obbligatorio. Il formato dei dati di output. |
Campo unione destination. Obbligatorio. destination può essere solo uno dei seguenti tipi: |
|
gcs_destination |
La località di Google Cloud Storage in cui scrivere l'output. |
RouteModifiers
Incapsula un insieme di condizioni facoltative da soddisfare durante il calcolo dei percorsi dei veicoli. Questo è simile a RouteModifiers nell'API Routes Preferred di Google Maps Platform; consulta: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers.
| Campi | |
|---|---|
avoid_tolls |
Specifica se evitare le strade a pedaggio, se possibile. Verrà data la preferenza ai percorsi che non contengono strade a pedaggio. Si applica solo alle modalità di viaggio motorizzate. |
avoid_highways |
Specifica se evitare le autostrade, se possibile. Verrà data la preferenza ai percorsi che non contengono autostrade. Si applica solo alle modalità di viaggio motorizzate. |
avoid_ferries |
Specifica se evitare i traghetti, se ragionevole. Verrà data la preferenza ai percorsi che non prevedono l'utilizzo di traghetti. Si applica solo alle modalità di viaggio motorizzate. |
avoid_indoor |
Facoltativo. Specifica se evitare la navigazione in ambienti chiusi, se possibile. Verrà data la preferenza ai percorsi che non contengono la navigazione interna. Si applica solo alla modalità di viaggio |
Spedizione
La spedizione di un singolo articolo, da uno dei suoi ritiri a una delle sue consegne. Affinché la spedizione venga considerata come eseguita, un veicolo univoco deve visitare una delle sue località di ritiro (e ridurre di conseguenza le sue capacità residue), quindi visitare una delle sue località di consegna in un secondo momento (e quindi aumentare di nuovo le sue capacità residue di conseguenza).
| Campi | |
|---|---|
display_name |
Il nome visualizzato della spedizione definito dall'utente. Può contenere fino a 63 caratteri e può utilizzare caratteri UTF-8. |
pickups[] |
Insieme di alternative di ritiro associate alla spedizione. Se non specificato, il veicolo deve visitare solo una località corrispondente alle consegne. |
deliveries[] |
Insieme di alternative di consegna associate alla spedizione. Se non specificato, il veicolo deve visitare solo una località corrispondente ai ritiri. |
load_demands |
Requisiti di carico della spedizione (ad esempio peso, volume, numero di pallet e così via). Le chiavi nella mappa devono essere identificatori che descrivono il tipo di carico corrispondente, idealmente includendo anche 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. |
allowed_vehicle_indices[] |
L'insieme di veicoli che possono eseguire questa spedizione. Se il campo è vuoto, tutti i veicoli possono eseguirla. I veicoli sono indicati dal loro indice nell'elenco |
costs_per_vehicle[] |
Specifica il costo sostenuto quando questa spedizione viene consegnata da ciascun veicolo. Se specificato, deve avere:
Questi costi devono essere espressi nella stessa unità di |
costs_per_vehicle_indices[] |
Indici dei veicoli a cui si applica |
pickup_to_delivery_absolute_detour_limit |
Specifica il tempo di deviazione assoluto massimo rispetto al percorso più breve dal ritiro alla consegna. Se specificato, deve essere un valore non negativo e la spedizione deve contenere almeno un ritiro e una consegna. Ad esempio, supponiamo che t sia il tempo più breve impiegato per andare dall'alternativa di ritiro selezionata direttamente all'alternativa di consegna selezionata. In questo caso, l'impostazione Se per la stessa spedizione vengono specificati sia limiti relativi che assoluti, per ogni possibile coppia di ritiro/consegna viene utilizzato il limite più restrittivo. A partire da ottobre 2017, le deviazioni sono supportate solo quando le durate dei viaggi non dipendono dai veicoli. |
pickup_to_delivery_time_limit |
Specifica la durata massima dall'inizio del ritiro all'inizio della consegna di una spedizione. Se specificato, deve essere non negativo e la spedizione deve contenere almeno un ritiro e una consegna. Questo 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. |
shipment_type |
Stringa non vuota che specifica un "tipo" per questa spedizione. Questa funzionalità può essere utilizzata per definire incompatibilità o requisiti tra Differisce da |
label |
Specifica un'etichetta per questa spedizione. Questa etichetta viene riportata nella risposta nel campo |
ignore |
Se true, salta questa spedizione, ma non applicare un Se ignori una spedizione, si verifica un errore di convalida quando nel modello sono presenti È consentito ignorare una spedizione eseguita in |
penalty_cost |
Se la spedizione non viene completata, questa penalità viene aggiunta al costo complessivo dei percorsi. Una spedizione è considerata completata se viene visitata una delle sue 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 penalità non viene specificata, viene considerata infinita, ovvero la spedizione deve essere completata. |
pickup_to_delivery_relative_detour_limit |
Specifica il tempo di deviazione relativo massimo rispetto al percorso più breve dal ritiro alla consegna. Se specificato, deve essere un valore non negativo e la spedizione deve contenere almeno un ritiro e una consegna. Ad esempio, supponiamo che t sia il tempo più breve impiegato per andare dall'alternativa di ritiro selezionata direttamente all'alternativa di consegna selezionata. In questo caso, l'impostazione Se per la stessa spedizione vengono specificati sia limiti relativi che assoluti, per ogni possibile coppia di ritiro/consegna viene utilizzato il limite più restrittivo. A partire da ottobre 2017, le deviazioni sono supportate solo quando le durate dei viaggi non dipendono dai veicoli. |
Carica
Quando si esegue una visita, un importo predefinito può essere aggiunto al carico del veicolo se si tratta di un ritiro o sottratto se si tratta di una consegna. Questo messaggio definisce questo importo. Leggi i load_demands.
| Campi | |
|---|---|
amount |
La quantità di variazione del carico del veicolo che esegue la visita corrispondente. Poiché si tratta di un numero intero, consigliamo agli utenti di scegliere un'unità appropriata per evitare la perdita di precisione. Deve essere ≥ 0. |
VisitRequest
Richiesta di una visita che può essere eseguita da un veicolo: ha una posizione geografica (o due, vedi sotto), orari di apertura e chiusura rappresentati da finestre temporali e una durata del servizio (tempo trascorso dal veicolo una volta arrivato per il ritiro o la consegna delle merci).
| Campi | |
|---|---|
arrival_location |
La posizione geografica in cui arriva il veicolo quando esegue questa |
arrival_waypoint |
Il waypoint in cui arriva il veicolo quando esegue questa |
departure_location |
La posizione geografica da cui parte il veicolo dopo aver completato questo |
departure_waypoint |
Il waypoint da cui parte il veicolo dopo aver completato questo |
tags[] |
Specifica i tag associati alla richiesta di visita. Non sono consentite stringhe vuote o duplicate. |
time_windows[] |
Finestre temporali che limitano l'ora di arrivo di una visita. Tieni presente che un veicolo può partire al di fuori della finestra temporale di arrivo, ovvero l'ora di arrivo + la durata non devono necessariamente rientrare in una finestra temporale. Ciò può comportare un tempo di attesa se il veicolo arriva prima di L'assenza di Le finestre temporali devono essere disgiunte, ovvero nessuna finestra temporale deve sovrapporsi o essere adiacente a un'altra e devono essere in ordine crescente.
|
duration |
Durata della visita, ovvero il tempo trascorso dal veicolo tra l'arrivo e la partenza (da aggiungere all'eventuale tempo di attesa; vedi |
cost |
Costo per gestire questa richiesta di visita su un percorso del veicolo. Può essere utilizzato per pagare costi diversi per ogni ritiro o consegna alternativi di una spedizione. Questo costo deve essere espresso nella stessa unità di |
load_demands |
Requisiti di carico di questa richiesta di visita. Questo campo è simile al campo |
visit_types[] |
Specifica i tipi di visita. Può essere utilizzato per assegnare il tempo aggiuntivo necessario a un veicolo per completare la visita (vedi Un tipo può essere visualizzato una sola volta. |
label |
Specifica un'etichetta per questo |
avoid_u_turns |
Specifica se evitare le inversioni a U nei percorsi in auto in questa località. L'evitamento delle inversioni a U è un'operazione "best effort" e l'evitamento completo non è garantito. Questa è una funzionalità sperimentale e il comportamento è soggetto a modifiche. Sperimentale: per maggiori dettagli, consulta https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request. |
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 del routing dei veicoli (somma del costo per tempo totale, del costo per tempo di percorrenza e del costo fisso per tutti i veicoli).
- le penali per la mancata spedizione.
- il costo della durata complessiva delle spedizioni
| Campi | |
|---|---|
shipments[] |
Insieme di spedizioni che devono essere eseguite nel modello. |
vehicles[] |
Insieme di veicoli che possono essere utilizzati per eseguire le visite. |
objectives[] |
L'insieme di obiettivi per questo modello, che trasformeremo in costi. Se non è vuoto, il modello di input deve essere senza costi. Per ottenere la richiesta modificata, utilizza Sperimentale: per ulteriori dettagli, consulta la pagina https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request. |
global_start_time |
Ora di inizio e di fine globale del modello: non possono essere considerate valide ore al di fuori di questo intervallo. L'intervallo di tempo del modello deve essere inferiore a un anno, ovvero Quando utilizzi i campi |
global_end_time |
Se non impostato, viene utilizzato il valore predefinito 00:00:00 UTC, 1° gennaio 1971 (ovvero secondi: 31536000, nanos: 0). |
global_duration_cost_per_hour |
La "durata globale" del piano complessivo è la differenza tra l'ora di inizio effettiva più remota e l'ora di fine effettiva più recente di tutti i veicoli. Gli utenti possono assegnare un costo orario a questa quantità per cercare di ottimizzare, ad esempio, il completamento più rapido del job. Questo costo deve essere nella stessa unità di |
duration_distance_matrices[] |
Specifica le matrici di durata e Distance Matrix utilizzate nel modello. Se questo campo è vuoto, verranno utilizzate le distanze di Google Maps o geodetiche, a seconda del valore del campo Esempi di utilizzo:
|
duration_distance_matrix_src_tags[] |
Tag che definiscono le origini delle matrici di durata e Distance Matrix; I tag corrispondono a |
duration_distance_matrix_dst_tags[] |
Tag che definiscono le destinazioni delle matrici di durata e Distance Matrix; I tag corrispondono a |
transition_attributes[] |
Attributi di transizione aggiunti al modello. |
shipment_type_incompatibilities[] |
Insiemi di shipment_type incompatibili (vedi |
shipment_type_requirements[] |
Insiemi di requisiti |
precedence_rules[] |
Insieme di regole di precedenza che devono essere applicate nel modello. IMPORTANTE: l'utilizzo delle regole di precedenza limita le dimensioni del problema che può essere ottimizzato. Le richieste che utilizzano regole di precedenza che includono molte spedizioni potrebbero essere rifiutate. |
max_active_vehicles |
Limita il numero massimo di veicoli attivi. Un veicolo è attivo se il suo percorso esegue almeno una spedizione. Questo può essere utilizzato per limitare il numero di percorsi nel caso in cui ci siano meno conducenti che veicoli e il parco veicoli sia eterogeneo. L'ottimizzazione selezionerà quindi il sottoinsieme migliore di veicoli da utilizzare. Deve essere un numero strettamente positivo. |
DurationDistanceMatrix
Specifica una matrice di durata e Distance Matrix dalle località di partenza delle visite e dei veicoli alle località di arrivo delle visite e dei veicoli.
| Campi | |
|---|---|
rows[] |
Specifica le righe della matrice di durata e distanza. Deve contenere lo stesso numero di elementi di |
vehicle_start_tag |
Tag che definisce i veicoli a cui si applica questa Distance Matrix di durata e distanza. Se non viene specificato, si applica a tutti i veicoli e può esistere una sola matrice. Ogni partenza del veicolo deve corrispondere esattamente a una matrice, ovvero esattamente uno dei campi Tutte le matrici devono avere un |
Riga
Specifica una riga della matrice di durata e distanza.
| Campi | |
|---|---|
durations[] |
Valori di durata per una determinata riga. Deve contenere lo stesso numero di elementi di |
meters[] |
Valori di distanza per una determinata riga. Se nessun costo o vincolo fa riferimento alle distanze nel modello, questo campo può essere lasciato vuoto; in caso contrario, deve contenere lo stesso numero di elementi di |
Obiettivo
Gli obiettivi sostituiscono completamente il modello di costo e, pertanto, non sono compatibili con i costi preesistenti. Ogni obiettivo corrisponde a un numero di costi predefiniti, ad esempio per veicoli, spedizioni o attributi di transizione.
Sperimentale: per ulteriori dettagli, consulta la pagina https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.
| Campi | |
|---|---|
type |
Il tipo di obiettivo. |
weight |
Quanto deve contare questo obiettivo rispetto agli altri. Può essere qualsiasi numero non negativo; la somma dei pesi non deve essere necessariamente pari a 1. Il valore predefinito dei pesi è 1,0. |
Tipo
Il tipo di obiettivo che verrà mappato a un insieme di costi.
| Enum | |
|---|---|
DEFAULT |
Verrà utilizzato un insieme di costi predefinito per garantire una soluzione ragionevole. Nota: questo obiettivo può essere utilizzato da solo, ma verrà sempre aggiunto con un peso di 1,0, come base di riferimento, agli obiettivi specificati dall'utente, se non è già presente. |
MIN_DISTANCE |
"MIN". Ridurre al minimo la distanza totale percorsa. |
MIN_WORKING_TIME |
Ridurre al minimo il tempo di lavoro totale, sommato per tutti i veicoli. |
MIN_TRAVEL_TIME |
Come sopra, ma concentrandosi solo sul tempo di percorrenza. |
MIN_NUM_VEHICLES |
Ridurre al minimo il numero di veicoli utilizzati. |
PrecedenceRule
Una regola di precedenza tra due eventi (ogni evento è il ritiro o la consegna di una spedizione): il "secondo" evento deve iniziare almeno offset_duration dopo l'inizio del "primo".
Più precedenze possono fare riferimento agli stessi eventi (o a eventi 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 spedizioni, altrimenti vengono ignorate.
| Campi | |
|---|---|
first_is_delivery |
Indica se il "primo" evento è una consegna. |
second_is_delivery |
Indica se il "secondo" evento è una consegna. |
offset_duration |
L'offset tra il "primo" e il "secondo" evento. Può essere negativo. |
first_index |
Indice della spedizione del "primo" evento. Questo campo deve essere specificato. |
second_index |
Indice della spedizione del "secondo" evento. Questo campo deve essere specificato. |
ShipmentRoute
Il percorso di un veicolo può essere scomposto, lungo l'asse temporale, 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
Tieni presente che facciamo una distinzione 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 secondo specifico.
- "intervalli di tempo", come le visite stesse e la transizione tra le visite. Sebbene gli intervalli di tempo possano talvolta avere una durata pari a zero, ovvero iniziare e terminare nello stesso secondo, spesso hanno una durata positiva.
Invarianti:
- Se ci sono n visite, ci sono n+1 transizioni.
- Una visita è sempre preceduta da una transizione (stesso indice) e seguita da una transizione (indice + 1).
- La partenza del veicolo è sempre seguita dalla transizione n. 0.
- La fine del veicolo è sempre preceduta dalla transizione #n.
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 possono essere organizzati i tempi di VIAGGIO, PAUSA, RITARDO e ATTESA durante una transizione.
- Non si sovrappongono.
- Il DELAY è univoco e deve essere un periodo di tempo contiguo immediatamente precedente alla visita successiva (o alla fine del veicolo). Pertanto, è sufficiente conoscere la durata del ritardo per conoscerne l'ora di inizio e di fine.
- Le PAUSE 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 client 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 | | | | ||
|| | | | | | | ||
--++-----------------------------------------------------------------++-->
| Campi | |
|---|---|
vehicle_index |
Veicolo che esegue il percorso, identificato dal suo indice nell'origine |
vehicle_label |
Etichetta del veicolo che esegue questo percorso, uguale a |
vehicle_start_time |
L'ora in cui il veicolo inizia il percorso. |
vehicle_end_time |
L'ora in cui il veicolo termina il suo percorso. |
visits[] |
Sequenza ordinata di visite che rappresentano un percorso. visits[i] è la i-esima visita nel percorso. Se questo campo è vuoto, il veicolo è considerato non utilizzato. |
transitions[] |
Elenco ordinato delle transizioni per il percorso. |
has_traffic_infeasibilities |
Quando L'arrivo alla prossima visita avverrà probabilmente più tardi rispetto alla finestra temporale attuale a causa dell'aumento del tempo di percorrenza stimato |
route_polyline |
La rappresentazione della polilinea codificata del percorso. Questo campo viene compilato solo se |
breaks[] |
Pause programmate per il veicolo che esegue questo percorso. La sequenza |
metrics |
Metriche di durata, distanza e carico per questo percorso. I campi di |
vehicle_fullness |
Campo Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
route_costs |
Costo del percorso, suddiviso per campi di richiesta relativi ai costi. 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 di costo corrispondente, aggregato per l'intero percorso. In altre parole, costs["model.shipments.pickups.cost"] è la somma di tutti i costi del 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 da gennaio 2022. |
route_total_cost |
Costo totale del percorso. La somma di tutti i costi nella mappa dei costi. |
Pausa
Dati che rappresentano l'esecuzione di un'interruzione.
| Campi | |
|---|---|
start_time |
Ora di inizio di un'interruzione. |
duration |
Durata di una pausa. |
EncodedPolyline
La rappresentazione codificata di una polilinea. Per saperne di più sulla codifica delle polilinee, consulta queste pagine: https://developers.google.com/maps/documentation/utilities/polylinealgorithm https://developers.google.com/maps/documentation/javascript/reference/geometry#encoding.
| Campi | |
|---|---|
points |
Stringa che rappresenta i punti codificati della polilinea. |
Transizione
Transizione tra due eventi sul percorso. Consulta la descrizione di ShipmentRoute.
Se il veicolo non ha un start_location e/o un end_location, le metriche di viaggio corrispondenti sono pari a 0.
| Campi | |
|---|---|
travel_duration |
Durata del viaggio durante questa transizione. |
travel_distance_meters |
Distanza percorsa durante la transizione. |
traffic_info_unavailable |
Quando il traffico viene richiesto tramite |
delay_duration |
Somma delle durate dei ritardi applicati a questa transizione. Se presente, il ritardo inizia esattamente |
break_duration |
Somma della durata delle pause che si verificano durante questa transizione, se presenti. I dettagli sull'ora di inizio e sulla durata di ogni interruzione sono memorizzati in |
wait_duration |
Tempo trascorso in attesa durante questa transizione. La durata dell'attesa corrisponde al tempo di inattività e non include il tempo di pausa. Tieni presente inoltre che questo tempo di attesa potrebbe essere suddiviso in diversi intervalli non contigui. |
total_duration |
Durata totale della transizione, fornita per praticità. È uguale a:
|
start_time |
Ora di inizio di questa transizione. |
route_polyline |
La rappresentazione della polilinea codificata del percorso seguito durante la transizione. Questo campo viene compilato solo se |
route_token |
Solo output. Un token opaco che può essere passato all'SDK di navigazione per ricostruire il percorso durante la navigazione e, in caso di cambio percorso, rispettare l'intenzione originale al momento della creazione del percorso. Tratta questo token come un blob opaco. Non confrontare il suo valore tra le richieste, poiché potrebbe cambiare anche se il servizio restituisce lo stesso percorso. Questo campo viene compilato solo se |
vehicle_loads |
Carichi del veicolo durante questa transizione, per ogni tipo che appare nel I carichi durante la prima transizione sono i carichi iniziali del percorso del veicolo. Poi, dopo ogni visita, i |
VehicleLoad
Segnala il carico effettivo del veicolo in un punto lungo il percorso, per un determinato tipo (vedi Transition.vehicle_loads).
| Campi | |
|---|---|
amount |
La quantità di carico sul veicolo per il tipo specificato. L'unità di carico è solitamente indicata dal tipo. Leggi i |
Visita
Una visita effettuata durante un percorso. Questa visita corrisponde a un ritiro o a una consegna di un Shipment.
| Campi | |
|---|---|
shipment_index |
Indice del campo |
is_pickup |
Se true, la visita corrisponde al ritiro di un |
visit_request_index |
Indice di |
start_time |
L'ora di inizio della visita. Tieni presente che il veicolo potrebbe arrivare prima di questo orario nel luogo della visita. Gli orari sono coerenti con il |
load_demands |
Domanda di carico totale della visita come somma della spedizione e della richiesta di visita |
detour |
Tempo di deviazione aggiuntivo dovuto alle spedizioni visitate sul percorso prima della visita e al potenziale tempo di attesa indotto dalle finestre temporali. Se la visita è una consegna, la deviazione viene calcolata dalla visita di ritiro corrispondente ed è pari a: In caso contrario, viene calcolato a partire dal |
shipment_label |
Copia del |
visit_label |
Copia del |
visit_type |
Facoltativo. Specifica il tipo di visita. Esegue l'override del campo |
injected_solution_location_token |
Un token opaco che rappresenta le informazioni su una località visitata. Questo campo può essere compilato nelle visite dei percorsi dei risultati quando Sperimentale: per maggiori dettagli, consulta https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request. |
VisitType
Indica se la visita è un ritiro, una consegna o una visita a un Stop. Le visite a una fermata vengono utilizzate solo quando è attiva l'ottimizzazione multimodale.
| Enum | |
|---|---|
VISIT_TYPE_UNSPECIFIED |
Tipo di visita non specificato. |
PICKUP_SHIPMENT |
La visita corrisponde al ritiro di una spedizione. |
DELIVER_SHIPMENT |
La visita corrisponde alla consegna di una spedizione. |
ShipmentTypeIncompatibility
Specifica le incompatibilità tra le spedizioni in base al relativo shipment_type. La presenza di spedizioni incompatibili sullo stesso percorso è limitata in base alla modalità di incompatibilità.
| Campi | |
|---|---|
types[] |
Elenco dei tipi non compatibili. Due spedizioni con |
incompatibility_mode |
Modalità applicata all'incompatibilità. |
IncompatibilityMode
Modalità che definiscono il modo in cui l'aspetto delle spedizioni incompatibili è limitato 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 |
In questa modalità, due spedizioni con tipi incompatibili non possono mai trovarsi sullo stesso veicolo contemporaneamente:
|
ShipmentTypeRequirement
Specifica i requisiti tra le spedizioni in base al relativo shipment_type. Le specifiche del requisito sono definite dalla modalità del requisito.
| Campi | |
|---|---|
required_shipment_type_alternatives[] |
Elenco dei tipi di spedizione alternativi richiesti da |
dependent_shipment_types[] |
Tutte le spedizioni con un tipo nel campo NOTA: non sono consentite catene di requisiti in cui un |
requirement_mode |
Modalità applicata al requisito. |
RequirementMode
Modalità che definiscono l'aspetto delle spedizioni dipendenti su un percorso.
| Enum | |
|---|---|
REQUIREMENT_MODE_UNSPECIFIED |
Modalità di 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 "richieste". |
IN_SAME_VEHICLE_AT_PICKUP_TIME |
Con la modalità Un ritiro della spedizione "dipendente" deve quindi avere:
|
IN_SAME_VEHICLE_AT_DELIVERY_TIME |
Come prima, con la differenza che le spedizioni "dipendenti" devono avere una spedizione "obbligatoria" sul veicolo al momento della consegna. |
SkippedShipment
Specifica i dettagli delle spedizioni non eseguite in una soluzione. Per i casi banali e/o se siamo in grado di identificare la causa del salto, riportiamo il motivo qui.
| Campi | |
|---|---|
index |
L'indice corrisponde all'indice della spedizione nell'origine |
label |
Copia del |
reasons[] |
Un elenco di motivi che spiegano perché la spedizione è stata saltata. Vedi il commento sopra |
penalty_cost |
Questa è una copia di Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
estimated_incompatible_vehicle_ratio |
Rapporto stimato di veicoli che non possono eseguire questa spedizione per almeno uno dei motivi indicati di seguito. Nota: questo campo viene compilato solo quando i motivi riguardano un veicolo. Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
Motivo
Se possiamo spiegare perché la spedizione è stata saltata, i motivi verranno elencati qui. Se il motivo non è uguale per tutti i veicoli, reason avrà più di un elemento. Una spedizione saltata non può avere motivi duplicati, ovvero in cui tutti i campi sono uguali ad eccezione di example_vehicle_index. Esempio:
reasons {
code: DEMAND_EXCEEDS_VEHICLE_CAPACITY
example_vehicle_index: 1
example_exceeded_capacity_type: "Apples"
}
reasons {
code: DEMAND_EXCEEDS_VEHICLE_CAPACITY
example_vehicle_index: 3
example_exceeded_capacity_type: "Pears"
}
reasons {
code: CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DISTANCE_LIMIT
example_vehicle_index: 1
}
La spedizione saltata non è compatibile con tutti i veicoli. I motivi possono essere diversi per tutti i veicoli, ma la capacità "Mele" di almeno un veicolo verrebbe superata (incluso il veicolo 1), la capacità "Pere" di almeno un veicolo verrebbe superata (incluso il veicolo 3) e il limite di distanza di almeno un veicolo verrebbe superato (incluso il veicolo 1).
| Campi | |
|---|---|
code |
Fai riferimento ai commenti di Code. |
example_vehicle_indices[] |
Come Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
example_exceeded_capacity_type |
Se il codice motivo è |
example_vehicle_index |
Se il motivo è correlato a un'incompatibilità tra spedizione e veicolo, questo campo fornisce l'indice di un veicolo pertinente. |
Codice
Codice che identifica il tipo di motivo. L'ordine qui non ha importanza. In particolare, non indica se un determinato motivo verrà visualizzato prima di un altro nella soluzione, se entrambi sono applicabili.
| Enum | |
|---|---|
CODE_UNSPECIFIED |
Non deve mai essere utilizzato. |
NO_VEHICLE |
Nel modello non è presente alcun veicolo, il che rende tutte le spedizioni non fattibili. |
DEMAND_EXCEEDS_VEHICLE_CAPACITY |
La domanda della spedizione supera la capacità di un veicolo per alcuni tipi di capacità, uno dei quali è example_exceeded_capacity_type. |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DISTANCE_LIMIT |
La distanza minima necessaria per eseguire questa spedizione, ovvero dal Tieni presente che per questo calcolo utilizziamo le distanze geodetiche. |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT |
Il tempo minimo necessario per eseguire questa spedizione, inclusi il tempo di percorrenza, il tempo di attesa e il tempo di servizio, supera il valore Nota: il tempo di percorrenza viene calcolato nello scenario migliore, ovvero come distanza geodetica x 36 m/s (circa 130 km/ora). |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TRAVEL_DURATION_LIMIT |
Come sopra, ma confrontiamo solo il tempo di percorrenza minimo e il travel_duration_limit del veicolo. |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TIME_WINDOWS |
Il veicolo non può eseguire questa spedizione nello scenario migliore (consulta CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT per il calcolo del tempo) se inizia alla prima ora di inizio: il tempo totale farebbe terminare il veicolo dopo l'ultima ora di fine. |
VEHICLE_NOT_ALLOWED |
Il campo allowed_vehicle_indices della spedizione non è vuoto e questo veicolo non appartiene alla spedizione. |
VEHICLE_IGNORED |
Il campo Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
SHIPMENT_IGNORED |
Il campo Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
SKIPPED_IN_INJECTED_SOLUTION_CONSTRAINT |
La spedizione viene saltata nel Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
VEHICLE_ROUTE_IS_FULLY_SEQUENCE_CONSTRAINED |
L'allentamento del percorso del veicolo specificato in Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
ZERO_PENALTY_COST |
La spedizione ha un costo di penalità pari a zero. Sebbene questa possa essere utile come scelta di modellazione avanzata, può anche spiegare a posteriori perché una spedizione è stata saltata. Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
TimeWindow
Le finestre temporali limitano l'orario di un evento, ad esempio l'ora di arrivo di una visita o l'ora di inizio e di fine di un veicolo.
I limiti rigidi della finestra temporale, start_time e end_time, applicano l'ora più recente e più remota dell'evento, in modo che start_time <= event_time <=
end_time. Il limite inferiore della finestra temporale flessibile, soft_start_time, esprime una preferenza per l'evento che si verifica in corrispondenza o dopo soft_start_time, sostenendo un costo proporzionale al tempo trascorso prima dell'ora di inizio flessibile. Il limite superiore della finestra temporale flessibile, soft_end_time, esprime una preferenza per l'evento che si verifica entro o prima di soft_end_time, sostenendo un costo proporzionale al tempo trascorso dopo soft_end_time. start_time, end_time, soft_start_time e soft_end_time devono rientrare nei limiti di tempo globali (vedi ShipmentModel.global_start_time e ShipmentModel.global_end_time) e devono rispettare:
0 <= `start_time` <= `end_time` and
0 <= `start_time` <= `soft_start_time` and
0 <= `soft_end_time` <= `end_time`.
| Campi | |
|---|---|
start_time |
L'ora di inizio della finestra temporale rigida. Se non specificato, verrà impostato su |
end_time |
L'ora di fine della finestra temporale rigida. Se non specificato, verrà impostato su |
soft_start_time |
L'ora di inizio graduale della finestra temporale. |
soft_end_time |
L'ora di fine flessibile della finestra temporale. |
cost_per_hour_before_soft_start_time |
Un costo orario aggiunto ad altri costi nel modello se l'evento si verifica prima di soft_start_time, calcolato come: Questo costo deve essere positivo e il campo può essere impostato solo se è stato impostato soft_start_time. |
cost_per_hour_after_soft_end_time |
Un costo orario aggiunto ad altri costi nel modello se l'evento si verifica dopo il giorno Questo costo deve essere positivo e il campo può essere impostato solo se è stato impostato |
TransitionAttributes
Specifica gli attributi delle transizioni tra due visite consecutive su un percorso. A una stessa transizione possono essere applicati più TransitionAttributes: in questo caso, tutti i costi aggiuntivi vengono sommati e viene applicato il vincolo o il limite più restrittivo (seguendo la semantica naturale "AND").
| Campi | |
|---|---|
src_tag |
Tag che definiscono l'insieme di transizioni (src->dst) a cui si applicano questi attributi. Una visita di origine o una partenza del veicolo corrisponde se e solo se il relativo |
excluded_src_tag |
Leggi i |
dst_tag |
Una visita alla destinazione o una fine del veicolo corrisponde se e solo se il relativo |
excluded_dst_tag |
Leggi i |
cost |
Specifica un costo per l'esecuzione di questa transizione. Questa unità è la stessa di tutti gli altri costi del modello e non deve essere negativa. Viene applicata in aggiunta a tutti gli altri costi esistenti. |
cost_per_kilometer |
Specifica un costo per chilometro applicato alla distanza percorsa durante l'esecuzione di questa transizione. Si somma a qualsiasi |
distance_limit |
Specifica un limite per la distanza percorsa durante l'esecuzione di questa transizione. A partire da giugno 2021, sono supportati solo i limiti flessibili. |
delay |
Specifica un ritardo che si verifica 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. |
Uri
Un URI (Universal Resource Identifier) che punta a una risorsa che può essere letta e scritta dall'API Route Optimization.
| Campi | |
|---|---|
uri |
L'URI della risorsa. La risorsa potrebbe non esistere ancora. I contenuti della risorsa sono codificati come JSON o textproto. Sono supportate solo le risorse Google Cloud Storage. Se la risorsa è codificata come JSON, il nome della risorsa deve avere il suffisso |
Veicolo
Modella un veicolo in un problema di spedizione. La risoluzione di un problema di spedizione creerà un percorso che inizia da start_location e termina in end_location per questo veicolo. Un percorso è una sequenza di visite (vedi ShipmentRoute).
| Campi | |
|---|---|
display_name |
Il nome visualizzato del veicolo definito dall'utente. Può contenere fino a 63 caratteri e può utilizzare caratteri UTF-8. |
travel_mode |
La modalità di viaggio, che influisce sulle strade utilizzabili dal veicolo e sulla sua velocità. Vedi anche |
route_modifiers |
Un insieme di condizioni da soddisfare che influiscono sul modo in cui vengono calcolati i percorsi per il veicolo specificato. |
start_location |
Posizione geografica in cui il veicolo inizia il percorso prima di ritirare le spedizioni. Se non specificato, il veicolo parte dal primo ritiro. Se il modello di spedizione ha matrici di durata e Distance Matrix, |
start_waypoint |
Waypoint che rappresenta una posizione geografica in cui il veicolo parte prima di ritirare le spedizioni. Se non viene specificato né |
end_location |
Posizione geografica in cui si trova il veicolo dopo aver completato l'ultimo |
end_waypoint |
Waypoint che rappresenta una posizione geografica in cui il veicolo si ferma dopo aver completato l'ultima |
start_tags[] |
Specifica i tag associati all'inizio del percorso del veicolo. Non sono consentite stringhe vuote o duplicate. |
end_tags[] |
Specifica i tag associati alla fine del percorso del veicolo. Non sono consentite stringhe vuote o duplicate. |
start_time_windows[] |
Finestre temporali durante le quali il veicolo può partire dalla località di partenza. Devono rientrare nei limiti di tempo globali (vedi i campi 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.
|
end_time_windows[] |
Finestre temporali durante le quali il veicolo può arrivare alla località di arrivo. Devono rientrare nei limiti di tempo globali (vedi i campi 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.
|
unloading_policy |
Policy di scarico applicata al veicolo. |
load_limits |
Capacità del veicolo (ad esempio peso, volume, numero di pallet). Le chiavi nella mappa sono gli identificatori del tipo di carico, coerenti con le chiavi del campo |
cost_per_hour |
Costi dei veicoli: tutti i costi si sommano e devono essere espressi nella stessa unità di 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'utilizzo di |
cost_per_traveled_hour |
Costo per ora di viaggio del percorso del veicolo. Questo costo viene applicato solo al tempo di percorrenza impiegato dal percorso (ovvero quello indicato in |
cost_per_kilometer |
Costo per chilometro del percorso del veicolo. Questo costo viene applicato alla distanza indicata in |
fixed_cost |
Costo fisso applicato se questo veicolo viene utilizzato per gestire una spedizione. |
used_if_route_is_empty |
Questo campo si applica ai veicoli solo quando il loro percorso non prevede spedizioni. Indica se il veicolo deve essere considerato usato o meno in questo caso. Se true, il veicolo si sposta dalla località di partenza a quella di arrivo anche se non effettua spedizioni e vengono presi in considerazione i costi di tempo e distanza derivanti dal viaggio dalla località di partenza a quella di arrivo. In caso contrario, non viaggia dalla località di partenza a quella di arrivo e non sono previsti |
route_duration_limit |
Limite applicato alla durata totale del percorso del veicolo. In un determinato |
travel_duration_limit |
Limite applicato alla durata del viaggio del percorso del veicolo. In un determinato |
route_distance_limit |
Limite applicato alla distanza totale del percorso del veicolo. In un determinato |
extra_visit_duration_for_visit_type |
Specifica una mappa dalle stringhe visit_types alle durate. La durata è il tempo aggiuntivo rispetto a Se una richiesta di visita ha più tipi, verrà aggiunta una durata per ogni tipo nella mappa. |
break_rule |
Descrive la pianificazione delle pause da applicare a questo veicolo. Se il campo è vuoto, non verranno programmate pause per questo veicolo. |
label |
Specifica un'etichetta per questo veicolo. Questa etichetta viene riportata nella risposta come |
ignore |
Se true, Se una spedizione viene eseguita da un veicolo ignorato in Se una spedizione viene eseguita da un veicolo ignorato in |
travel_duration_multiple |
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, significa che il veicolo è più lento e ha tempi di percorrenza doppi rispetto ai veicoli standard. Questo multiplo non influisce sulla durata delle visite. Influisce sul costo se vengono specificati ATTENZIONE: i tempi di percorrenza verranno arrotondati al secondo più vicino dopo l'applicazione di questo multiplo, ma prima di eseguire qualsiasi operazione numerica. Pertanto, un multiplo piccolo potrebbe comportare una perdita di precisione. Vedi anche |
DurationLimit
Un limite che definisce la durata massima del percorso di un veicolo. Può essere rigido o morbido.
Quando viene definito un campo di limite flessibile, devono essere definiti insieme sia la soglia massima flessibile sia il costo associato.
| Campi | |
|---|---|
max_duration |
Un limite rigido che limita la durata a un massimo di max_duration. |
soft_max_duration |
Un limite flessibile che non impone un limite di durata massima, ma che, se violato, comporta un costo per il percorso. Questo costo si aggiunge ad altri costi definiti nel modello, con la stessa unità. Se definito, |
quadratic_soft_max_duration |
Un limite flessibile che non impone un limite di durata massima, ma che, se violato, comporta un costo per il percorso, quadratico nella durata. Questo costo si aggiunge ad altri costi definiti nel modello, con la stessa unità. Se
|
cost_per_hour_after_soft_max |
Costo orario sostenuto se la soglia Il costo deve essere non negativo. |
cost_per_square_hour_after_quadratic_soft_max |
Costo per ora al quadrato sostenuto se viene violata la soglia Il costo aggiuntivo è pari a 0 se la durata è inferiore alla soglia, altrimenti il costo dipende dalla durata come segue: Il costo deve essere non negativo. |
LoadLimit
Definisce un limite di carico applicabile a un veicolo, ad esempio "questo camion può trasportare solo fino a 3500 kg". Leggi i load_limits.
| Campi | |
|---|---|
soft_max_load |
Un limite flessibile del carico. Leggi i |
cost_per_unit_above_soft_max |
Se il carico supera |
start_load_interval |
L'intervallo di carico accettabile del veicolo all'inizio del percorso. |
end_load_interval |
L'intervallo di carico accettabile del veicolo alla fine del percorso. |
max_load |
La quantità massima di carico accettabile. |
cost_per_kilometer |
Costo dello spostamento di un'unità di carico per un chilometro per questo veicolo. Questo valore può essere utilizzato come proxy per il consumo di carburante: se il carico è un peso (in Newton), il carico*chilometro ha la dimensione di un'energia. Sperimentale: per ulteriori dettagli, consulta https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request. |
cost_per_traveled_hour |
Costo del viaggio con un'unità di carico per un'ora per questo veicolo. Sperimentale: per ulteriori dettagli, consulta https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request. |
Intervallo
Intervallo di importi di ricarica accettabili.
| Campi | |
|---|---|
min |
Un carico minimo accettabile. Deve essere ≥ 0. Se vengono specificati entrambi, |
max |
Un carico massimo accettabile. Deve essere ≥ 0. Se non specificato, il carico massimo non è limitato da questo messaggio. Se vengono specificati entrambi, |
LoadCost
Costo dello spostamento di un'unità di carico durante un periodo di Transition. Per un determinato carico, il costo è la somma di due parti:
- min(load,
load_threshold) *cost_per_unit_below_threshold - max(0, carico -
load_threshold) *cost_per_unit_above_threshold
Con questo costo, le soluzioni preferiscono consegnare prima le domande elevate o, in modo equivalente, ritirare le domande elevate per ultime. Ad esempio, se un veicolo ha
load_limit {
key: "weight"
value {
cost_per_kilometer {
load_threshold: 15
cost_per_unit_below_threshold: 2.0
cost_per_unit_above_threshold: 10.0
}
}
}
e il suo percorso è inizio,ritiro,ritiro,consegna,consegna,fine con le transizioni:
transition { vehicle_load['weight'] { amount: 0 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 20 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
travel_distance_meters: 1000.0 }
allora il costo sostenuto da questo LoadCost è (cost_below * load_below * chilometri + cost_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 il valore di LoadCost lungo il percorso è 120,0.
Tuttavia, se il percorso è inizio,ritiro,consegna,ritiro,consegna,fine con transizioni:
transition { vehicle_load['weight'] { amount: 0 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
travel_distance_meters: 1000.0 }
allora 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
In questo caso, il valore di LoadCost sul percorso è 40,0.
LoadCost rende più costose le soluzioni con transizioni con carichi pesanti.
Sperimentale: per ulteriori dettagli, consulta https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.
| Campi | |
|---|---|
load_threshold |
Quantità di carico al di sopra della quale il costo di spostamento di un'unità di carico cambia da cost_per_unit_below_threshold a cost_per_unit_above_threshold. Deve essere >= 0. |
cost_per_unit_below_threshold |
Costo di spostamento di un'unità di carico, per ogni unità compresa tra 0 e la soglia. Deve essere un valore finito e >= 0. |
cost_per_unit_above_threshold |
Costo dello spostamento di un'unità di carico, per ogni unità superiore alla soglia. Nel caso speciale in cui la soglia è pari a 0, si tratta di un costo fisso per unità. Deve essere un valore finito e >= 0. |
TravelMode
Modalità di viaggio che possono essere utilizzate dai veicoli.
Queste dovrebbero essere un sottoinsieme delle modalità di viaggio dell'API Routes di Google Maps Platform, consulta: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode
Nota: i percorsi WALKING sono in versione beta e a volte potrebbero non includere marciapiedi o percorsi pedonali chiari. Devi mostrare questo avviso all'utente per tutti i percorsi a piedi che mostri nella tua app.
| 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 a piedi. |
UnloadingPolicy
Policy su come un veicolo può essere scaricato. Si applica solo alle spedizioni che prevedono sia il ritiro che la consegna.
Le altre spedizioni possono essere effettuate in qualsiasi punto del percorso, indipendentemente da unloading_policy.
| Enum | |
|---|---|
UNLOADING_POLICY_UNSPECIFIED |
Policy di scarico non specificata; le consegne devono avvenire 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 |
VehicleFullness
VehicleFullness è una metrica che calcola il livello di riempimento di un veicolo. Ogni campo VehicleFullness è compreso tra 0 e 1, calcolato come il rapporto tra un campo della metrica con limite (ad es. AggregatedMetrics.travel_distance_meters) e il relativo limite del veicolo (ad es. Vehicle.route_distance_limit), se esiste. In caso contrario, il rapporto di riempimento rimane non impostato. Se il limite è 0, il campo viene impostato su 1. Nota: quando un percorso è soggetto a problemi di traffico, alcuni rapporti di riempimento non elaborati potrebbero superare 1,0, ad esempio il veicolo potrebbe superare il limite di distanza. In questi casi, limitiamo i valori di pienezza a 1,0.
| Campi | |
|---|---|
max_fullness |
Numero massimo di tutti gli altri campi in questo messaggio. |
distance |
Il rapporto tra |
travel_duration |
Il rapporto tra [AggregatedMetrics.travel_duration_seconds][] e |
active_duration |
Il rapporto tra [AggregatedMetrics.total_duration_seconds][] e |
max_load |
Il rapporto massimo tra tutti i tipi di [AggregatedMetrics.max_load][] e i rispettivi |
active_span |
Il rapporto (vehicle_end_time - vehicle_start_time) / (latest_vehicle_end_time - earliest_vehicle_start_time) per un determinato veicolo. Se il denominatore non è presente, utilizza ( |
Waypoint
Incapsula un waypoint. I waypoint indicano le località di arrivo e partenza delle richieste di visita, nonché le località di partenza e di arrivo dei veicoli.
| Campi | |
|---|---|
side_of_road |
Facoltativo. Indica che la posizione di questo waypoint deve avere una preferenza per il veicolo che si ferma su un lato specifico 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 è orientata la località rispetto al centro della strada. Questa opzione non funziona per la modalità di viaggio "A PIEDI". |
vehicle_stopover |
Indica che la tappa è destinata alla sosta dei veicoli, con l'intenzione di far salire o scendere i passeggeri. Questa opzione funziona solo per la modalità di viaggio "DRIVING" e quando "location_type" è "location". Sperimentale: il comportamento o l'esistenza di questo campo potrebbero cambiare in futuro. |
Campo unione location_type. Diversi modi per rappresentare una località. location_type può essere solo uno dei seguenti tipi: |
|
location |
Un punto specificato utilizzando le coordinate geografiche, inclusa un'intestazione facoltativa. |
place_id |
L'ID luogo del PDI associato al waypoint. Quando utilizzi un ID luogo per specificare la località di arrivo o di partenza di una VisitRequest, utilizza un ID luogo sufficientemente specifico da determinare una località LatLng per la navigazione verso il luogo. Ad esempio, un ID luogo che rappresenta un edificio è adatto, ma un ID luogo che rappresenta una strada è sconsigliato. |