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)OptimizeToursRequest
(messaggio)OptimizeToursRequest.SearchMode
(enum)OptimizeToursRequest.SolvingMode
(enum)OptimizeToursResponse
(messaggio)OptimizeToursResponse.Metrics
(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.PrecedenceRule
(messaggio)ShipmentRoute
(messaggio)ShipmentRoute.Break
(messaggio)ShipmentRoute.EncodedPolyline
(messaggio)ShipmentRoute.Transition
(messaggio)ShipmentRoute.VehicleLoad
(messaggio)ShipmentRoute.Visit
(messaggio)ShipmentTypeIncompatibility
(messaggio)ShipmentTypeIncompatibility.IncompatibilityMode
(enum)ShipmentTypeRequirement
(messaggio)ShipmentTypeRequirement.RequirementMode
(enum)SkippedShipment
(messaggio)SkippedShipment.Reason
(messaggio)SkippedShipment.Reason.Code
(enum)TimeWindow
(messaggio)TransitionAttributes
(messaggio)Vehicle
(messaggio)Vehicle.DurationLimit
(messaggio)Vehicle.LoadLimit
(messaggio)Vehicle.LoadLimit.Interval
(messaggio)Vehicle.TravelMode
(enum)Vehicle.UnloadingPolicy
(enum)Waypoint
(messaggio)
RouteOptimization
Un servizio per l'ottimizzazione dei tour dei veicoli.
Validità di determinati tipi di campi:
google.protobuf.Timestamp
- Gli orari sono 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 non deve essere impostato o deve essere 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 non deve essere impostato o deve essere 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 tra latitudine e longitudine deve essere diverso da zero.
BatchOptimizeTours |
---|
Ottimizza i tour 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
|
AggregatedMetrics
Metriche aggregate per ShipmentRoute
(rispettivamente per OptimizeToursResponse
su tutti gli elementi Transition
e/o Visit
(rispettivamente su tutti gli elementi ShipmentRoute
).
Campi | |
---|---|
performed_ |
Numero di spedizioni eseguite. Tieni presente che una coppia di ritiro e consegna viene conteggiata una sola volta. |
travel_ |
Durata totale del viaggio per un itinerario o una soluzione. |
wait_ |
La durata totale dell'attesa per un itinerario o una soluzione. |
delay_ |
Durata totale del ritardo per un itinerario o una soluzione. |
break_ |
La durata totale dell'interruzione per un percorso o una soluzione. |
visit_ |
Durata totale della visita per un itinerario o una soluzione. |
total_ |
La durata totale deve essere uguale alla somma di tutte le durate sopra indicate. Per i percorsi, corrisponde anche a:
|
travel_ |
Distanza totale percorsa per un itinerario o una soluzione. |
max_ |
Carico massimo raggiunto nell'intero percorso (risp. nella soluzione), per ciascuna delle quantità su questo percorso (risp. nella soluzione), calcolato come il massimo su tutti i |
BatchOptimizeToursMetadata
Questo tipo non contiene campi.
Metadati dell'operazione per le chiamate BatchOptimizeToursRequest
.
BatchOptimizeToursRequest
Richiedi di ottimizzare in batch i 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 di output devono trovarsi nello stesso progetto.
Campi | |
---|---|
parent |
Obbligatorio. Progetto e località di destinazione per effettuare una chiamata. Formato: * Se non viene specificata alcuna località, verrà scelta automaticamente una regione. |
model_ |
Obbligatorio. Informazioni di input/output di ciascun modello di acquisto, ad esempio percorsi file e formati di dati. |
AsyncModelConfig
Informazioni per risolvere un modello di ottimizzazione in modo asincrono.
Campi | |
---|---|
display_ |
Facoltativo. Nome del modello definito dall'utente, che può essere utilizzato come alias dagli utenti per tenere traccia dei modelli. |
input_ |
Obbligatorio. Informazioni sul modello di input. |
output_ |
Obbligatorio. Le informazioni sulla posizione di output desiderata. |
BatchOptimizeToursResponse
Questo tipo non contiene campi.
Risposta a un BatchOptimizeToursRequest
. Viene restituito nell'operazione a lunga esecuzione al termine dell'operazione.
BreakRule
Regole per generare interruzioni di tempo per un veicolo (ad es. pause pranzo). Una pausa è un periodo di tempo contiguo durante il quale il veicolo rimane inattivo nella sua posizione corrente e non può effettuare alcuna visita. Una interruzione può verificarsi:
- durante il tragitto tra due visite (che include il tempo immediatamente prima o dopo una visita, ma non nel mezzo di una visita), in cui caso viene esteso il tempo di transito corrispondente tra le visite,
- o prima dell'avvio del veicolo (il veicolo potrebbe non avviarsi nel mezzo di una pausa), nel qual caso non influisce sull'ora di inizio del veicolo.
- o dopo la fine del servizio (idem, con l'ora di fine del servizio).
Campi | |
---|---|
break_ |
Sequenza di interruzioni. Visualizza il messaggio |
frequency_ |
Potrebbero essere applicati diversi |
BreakRequest
La sequenza delle interruzioni (ovvero il numero e l'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 relative finestre temporali (earliest_start_time
/ latest_start_time
) possono sovrapporsi, ma devono essere compatibili con l'ordine (questo viene controllato).
Campi | |
---|---|
earliest_ |
Obbligatorio. Limite inferiore (incluso) all'inizio dell'interruzione. |
latest_ |
Obbligatorio. Limite superiore (incluso) all'inizio dell'interruzione. |
min_ |
Obbligatorio. Durata minima dell'interruzione. Il valore deve essere positivo. |
FrequencyConstraint
È possibile limitare ulteriormente la frequenza e la durata delle interruzioni specificate sopra, imponendo una frequenza minima delle interruzioni, ad esempio "Deve essere presente un'interruzione di almeno 1 ora ogni 12 ore". Supponendo che questo possa essere interpretato come "In qualsiasi finestra temporale scorrevole di 12 ore, deve esserci almeno una pausa di almeno un'ora", questo esempio si tradurrebbe nel seguente FrequencyConstraint
:
{
min_break_duration { seconds: 3600 } # 1 hour.
max_inter_break_duration { seconds: 39600 } # 11 hours (12 - 1 = 11).
}
La tempistica e la durata delle interruzioni nella soluzione rispetteranno tutti questi vincoli, oltre alle finestre di tempo e alle durate minime già specificate in BreakRequest
.
In pratica, un FrequencyConstraint
può essere applicato a interruzioni 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_ |
Obbligatorio. Durata minima dell'interruzione per questo vincolo. Non negativo. Leggi la descrizione di |
max_ |
Obbligatorio. Periodo massimo consentito di qualsiasi intervallo di tempo nel percorso che non include almeno parzialmente un'interruzione di |
DataFormat
Formati dei dati per i file di input e di output.
Enum | |
---|---|
DATA_FORMAT_UNSPECIFIED |
Valore non valido, il formato non deve essere UNSPECIFIED. |
JSON |
JavaScript Object Notation. |
PROTO_TEXT |
Formato di testo Protocol Buffers. Consulta https://protobuf.dev/reference/protobuf/textformat-spec/ |
DistanceLimit
Un limite che definisce la distanza massima che può essere percorsa. Può essere dura o morbida.
Se è definito un limite flessibile, sia soft_max_meters
che cost_per_kilometer_above_soft_max
devono essere definiti e non negativi.
Campi | |
---|---|
max_ |
Un limite massimo che impone che la distanza non superi max_meters. Il limite deve essere non negativo. |
soft_ |
Un limite flessibile che non applica un limite di distanza massima, ma che, se violato, genera un costo che si somma agli altri costi definiti nel modello, con la stessa unità di misura. Se definito, soft_max_meters deve essere inferiore a max_meters e non deve essere negativo. |
cost_ |
Costo per chilometro sostenuto, che aumenta fino a
Questo costo non è supportato in |
cost_ |
Costo per chilometro addebitato se la distanza supera il limite di
Il costo deve essere non negativo. |
GcsDestination
La posizione di Google Cloud Storage in cui verranno scritti i file di output.
Campi | |
---|---|
uri |
Obbligatorio. URI Google Cloud Storage. |
GcsSource
La posizione 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 iniettata nella richiesta, incluse informazioni sulle visite che devono essere limitate e su come devono essere limitate.
Campi | |
---|---|
routes[] |
Percorsi della soluzione da iniettare. 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_ |
Caricamenti della soluzione da inserire ignorati. Alcuni potrebbero essere omessi dalla soluzione originale. Consulta il campo |
constraint_ |
Per zero o più gruppi di veicoli, specifica quando e in che misura allentare i vincoli. Se questo campo è vuoto, tutti i percorsi dei veicoli non vuoti sono completamente vincolati. |
ConstraintRelaxation
Per un gruppo di veicoli, specifica a quali soglie verranno allentati i vincoli sulle visite e a quale livello. Le spedizioni elencate nel campo skipped_shipment
devono essere ignorate, ovvero non possono essere eseguite.
Campi | |
---|---|
relaxations[] |
Tutti gli allentamento dei vincoli di visita che verranno applicati alle visite sui percorsi con veicoli in |
vehicle_ |
Specifica gli indici dei veicoli a cui si applica la limitazione di visita Un indice del veicolo viene mappato come |
Relax
Se relaxations
è vuoto, l'ora di inizio e la sequenza di tutte le visite su relaxations
sono completamente vincolate e non è possibile inserire o aggiungere nuove visite a questi percorsi.routes
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 delle restrizioni applicato a una visita #j che soddisfa:
route.visits(j).start_time >= relaxations(i).threshold_time
Ej + 1 >= relaxations(i).threshold_visit_count
Analogamente, l'avvio del veicolo viene allentato a relaxations(i).level
se soddisfa i seguenti requisiti:
vehicle_start_time >= relaxations(i).threshold_time
Erelaxations(i).threshold_visit_count == 0
e l'estremità del veicolo è allentata arelaxations(i).level
se soddisfa:vehicle_end_time >= relaxations(i).threshold_time
Eroute.visits_size() + 1 >= relaxations(i).threshold_visit_count
Per applicare un livello di rilassamento se una visita soddisfa il threshold_visit_count
OPPURE il 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ù flessibile. Di conseguenza, dal punto di partenza del veicolo fino alle visite del percorso fino al punto di arrivo del veicolo, il livello di rilassamento diventa più rilassato: in altre parole, 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 qualsiasi relaxations
sono completamente vincolate e non è possibile inserire visite in queste sequenze. Inoltre, se l'inizio o la fine di un veicolo non soddisfa le condizioni di alcun allentamento, l'ora è fissa, a meno che il veicolo non sia vuoto.
Campi | |
---|---|
level |
Il livello di rilassamento delle limitazioni che si applica quando le condizioni a partire da |
threshold_ |
L'ora a partire dalla quale è possibile applicare il rilassamento |
threshold_ |
Il numero di visite a partire dal quale è possibile applicare il rilassamento Se è |
Livello
Esprime i diversi livelli di rilassamento dei vincoli, che vengono applicati per una visita e quelli che seguono quando soddisfa le condizioni di soglia.
L'enumerazione riportata di seguito è in ordine di rilassamento crescente.
Enum | |
---|---|
LEVEL_UNSPECIFIED |
Livello di rilassamento predefinito implicito: non vengono applicati rilassamenti, ovvero tutte le visite sono completamente vincolate. Questo valore non deve essere utilizzato esplicitamente in |
RELAX_VISIT_TIMES_AFTER_THRESHOLD |
Gli orari di inizio e fine delle visite e dei veicoli saranno meno rigidi, ma ogni visita rimane associata allo stesso veicolo e la sequenza delle visite deve essere rispettata: non è possibile inserire visite tra una visita e l'altra o prima di una visita. |
RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD |
Come per RELAX_VISIT_TIMES_AFTER_THRESHOLD , ma la sequenza delle visite è meno rigida: le visite possono essere eseguite solo da questo veicolo, ma possono potenzialmente non essere eseguite. |
RELAX_ALL_AFTER_THRESHOLD |
Come per RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD , ma il veicolo è anche rilassato: le visite sono completamente senza costi all'ora di soglia o dopo e possono potenzialmente non essere eseguite. |
InputConfig
Specifica un input per [BatchOptimizeTours][google.maps.routeoptimization.v1.RouteOptimizationService.BatchOptimizeTours].
Campi | |
---|---|
data_ |
Obbligatorio. Il formato dei dati di input. |
Campo unione source . Obbligatorio. source può essere solo uno dei seguenti: |
|
gcs_ |
Una posizione di Google Cloud Storage. Deve essere un singolo oggetto (file). |
Località
Incapsula una posizione (un punto geografico e un'intestazione facoltativa).
Campi | |
---|---|
lat_ |
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 il reso. I valori di rotta possono variare da 0 a 360, dove 0 indica una rotta a nord, 90 indica una rotta a est e così via. |
OptimizeToursRequest
Richiesta da inviare a un risolutore di ottimizzazione del tour che definisce il modello di spedizione da risolvere, nonché i parametri di ottimizzazione.
Campi | |
---|---|
parent |
Obbligatorio. Progetto o località di destinazione per effettuare una chiamata. Formato: * Se non viene specificata alcuna località, verrà scelta automaticamente una regione. |
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 del caso. Per le richieste asincrone, il server genererà una soluzione (se possibile) prima del timeout. |
model |
Modello di spedizione da risolvere. |
solving_ |
Per impostazione predefinita, la modalità di risoluzione è |
search_ |
Modalità di ricerca utilizzata per risolvere la richiesta. |
injected_ |
Guida l'algoritmo di ottimizzazione a trovare una prima soluzione simile a una precedente. Il modello è vincolato quando viene creata la prima soluzione. Eventuali spedizioni non eseguite su un percorso vengono ignorate implicitamente nella prima soluzione, ma possono essere eseguite nelle soluzioni successive. La soluzione deve soddisfare alcune ipotesi di validità di base:
Se la soluzione iniettata non è fattibile, non viene necessariamente restituito un errore di convalida, ma potrebbe essere restituito un errore che indica l'impossibilità di applicazione. |
injected_ |
Limita l'algoritmo di ottimizzazione per trovare una soluzione finale simile a una precedente. Ad esempio, può essere utilizzato per bloccare parti di percorsi già completati o da completare, ma che non devono essere modificati. Se la soluzione iniettata non è fattibile, non viene necessariamente restituito un errore di convalida, ma potrebbe essere restituito un errore che indica l'impossibilità di applicazione. |
refresh_ |
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 problema del modello. A partire da novembre 2020, vengono compilati solo i polilinei dei percorsi non vuoti e I campi Questo campo non deve essere utilizzato insieme a
|
interpret_ |
Se true:
Questa interpretazione si applica ai campi Se true, le etichette nelle seguenti categorie devono apparire al massimo una volta nella rispettiva categoria:
Se un La rimozione di visite ai percorsi o di interi percorsi da una soluzione iniettata può influire sui vincoli impliciti, il che può comportare la modifica della soluzione, errori di convalida o l'impossibilità di applicazione. NOTA: l'utente che chiama deve assicurarsi che ogni |
consider_ |
Tieni conto della stima del traffico per calcolare i campi |
populate_ |
Se true, i polilinee verranno compilati nelle |
populate_ |
Se true, i polilinee e i token di percorso verranno compilati nella risposta |
allow_ |
Se questo valore è 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 a lungo termine presentano un rischio di interruzione notevolmente maggiore (ma comunque ridotto). |
use_ |
Se true, le distanze di viaggio verranno calcolate utilizzando le distanze geodetiche anziché quelle di Google Maps e i tempi di viaggio verranno calcolati utilizzando le distanze geodetiche con una velocità definita da |
label |
L'etichetta che può essere utilizzata per identificare questa richiesta, riportata in |
geodesic_ |
Quando |
max_ |
Tronca il numero di errori di convalida restituiti. Questi errori sono in genere associati al payload dell'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, con un compromesso tra latenza e 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 |
Interrompi la ricerca dopo aver trovato la prima soluzione valida. |
CONSUME_ALL_AVAILABLE_TIME |
Dedica tutto il tempo a tua disposizione alla ricerca di soluzioni migliori. |
SolvingMode
Definisce in che modo 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 il modello senza risolverlo: compila il maggior numero possibile di OptimizeToursResponse.validation_errors . |
DETECT_SOME_INFEASIBLE_SHIPMENTS |
Compila solo IMPORTANTE: non vengono restituite qui tutte le spedizioni non realizzabili, ma solo quelle rilevate come non realizzabili durante la preelaborazione. |
OptimizeToursResponse
Risposta dopo aver risolto un problema di ottimizzazione del tour contenente i percorsi seguiti da ciascun veicolo, le spedizioni che sono state saltate e il costo complessivo della soluzione.
Campi | |
---|---|
routes[] |
Percorsi calcolati per ogni veicolo; il percorso i-esimo corrisponde al veicolo i-esimo nel modello. |
request_ |
Copia del |
skipped_ |
L'elenco di tutte le spedizioni ignorate. |
validation_ |
Elenco di tutti gli errori di convalida che siamo riusciti a rilevare in modo indipendente. Consulta la spiegazione "ERRORI MULTIPLI" per il messaggio |
metrics |
Metriche relative a durata, distanza e utilizzo per questa soluzione. |
Metriche
Metriche complessive, aggregate per tutti i route.
Campi | |
---|---|
aggregated_ |
Aggregato per i percorsi. Ogni metrica è la somma (o il valore massimo, per i caricamenti) di tutti i campi |
skipped_ |
Numero di importazioni obbligatorie ignorate. |
used_ |
Numero di veicoli utilizzati. Nota: se il percorso di un veicolo è vuoto e |
earliest_ |
L'ora di inizio più antica per un veicolo usato, calcolata come valore minimo di |
latest_ |
L'ora di fine più recente per un veicolo usato, calcolata come valore massimo di |
costs |
Costo della soluzione, suddiviso in base ai campi delle richieste 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 del costo corrispondente, aggregato nell'intera soluzione. In altre parole, costs["model.shipments.pickups.cost"] è la somma di tutti i costi di ritiro della soluzione. Tutti i costi definiti nel modello sono riportati in dettaglio qui, ad eccezione dei costi relativi a TransitionAttributes, che vengono registrati solo in modo aggregato a partire da gennaio 2022. |
total_ |
Costo totale della soluzione. La somma di tutti i valori nella mappa dei costi. |
OptimizeToursValidationError
Descrive un errore o un avviso rilevato 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, la procedura di convalida tenta di generarne diversi. Come per un compilatore, si tratta di un processo imperfetto. Alcuni errori di convalida sono "fatali", il che significa che interrompono l'intera procedura di convalida. È il caso, ad esempio, degli errori STABILITÀ: |
display_ |
Il nome visualizzato dell'errore. |
fields[] |
Un contesto di errore può coinvolgere 0, 1 (la maggior parte delle volte) o più campi. Ad esempio, il riferimento al primo ritiro del veicolo 4 e della spedizione 2 può essere effettuato come segue:
Tieni presente, tuttavia, che la cardinalità di |
error_ |
Stringa leggibile che descrive l'errore. Esiste una mappatura 1:1 tra STABILITÀ: non stabile: il messaggio di errore associato a un determinato |
offending_ |
Può contenere i valori dei campi. Questa opzione non è sempre disponibile. Non devi assolutamente fare affidamento su questo valore e devi 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, potremmo specificare l'elemento 2 di start_time_windows
del veicolo 5 utilizzando:
name: "vehicles" index: 5 sub_field { name: "end_time_windows" index: 2 }
Tuttavia, ometteremo le entità di primo livello come OptimizeToursRequest
o ShipmentModel
per evitare di appesantire il messaggio.
Campi | |
---|---|
name |
Nome del campo, ad esempio "vehicles". |
sub_ |
Se necessario, sottocampo nidificato in modo ricorsivo. |
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_ |
Obbligatorio. Il formato dei dati di output. |
Campo unione destination . Obbligatorio. destination può essere solo uno dei seguenti: |
|
gcs_ |
La posizione 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. È 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_ |
Specifica se evitare le strade a pedaggio, ove ragionevole. Verrà data la preferenza ai percorsi che non includono strade a pedaggio. Si applica solo alle modalità di viaggio motorizzate. |
avoid_ |
Specifica se evitare le autostrade, ove possibile. Verrà data la preferenza ai percorsi che non contengono autostrade. Si applica solo alle modalità di viaggio motorizzate. |
avoid_ |
Specifica se evitare i traghetti, ove ragionevole. Verrà data la preferenza ai percorsi che non includono viaggi in traghetto. Si applica solo alle modalità di viaggio motorizzate. |
avoid_ |
Facoltativo. Specifica se evitare di navigare all'interno, ove ragionevole. Verrà data la preferenza ai percorsi che non contengono la navigazione al chiuso. Si applica solo alla modalità di viaggio |
Spedizione
La spedizione di un singolo articolo, da un ritiro a una consegna. Affinché la spedizione sia considerata eseguita, un veicolo unico deve visitare una delle sue stazioni di ritiro (e diminuire di conseguenza le relative capacità di riserva), quindi visitare in un secondo momento una delle sue stazioni di consegna (e quindi aumentare di conseguenza le relative capacità di riserva).
Campi | |
---|---|
display_ |
Il nome visualizzato della spedizione definito dall'utente. Può contenere fino a 63 caratteri e può utilizzare caratteri UTF-8. |
pickups[] |
Set di alternative di ritiro associate alla spedizione. Se non specificato, il veicolo deve visitare solo una località corrispondente alle consegne. |
deliveries[] |
Serie di alternative di consegna associate alla spedizione. Se non specificato, il veicolo deve visitare solo una stazione di ricarica corrispondente ai punti di ritiro. |
load_ |
Le richieste 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 incluse anche le unità di misura. Ad esempio: "weight_kg", "volume_gallons", "pallet_count" e così via. Se una determinata chiave non compare nella mappa, il carico corrispondente viene considerato nullo. |
allowed_ |
L'insieme di veicoli che possono effettuare questa spedizione. Se è vuoto, tutti i veicoli possono eseguirlo. I veicoli sono indicati dal relativo indice nell'elenco |
costs_ |
Specifica il costo sostenuto quando la spedizione viene consegnata da ciascun veicolo. Se specificato, deve avere OPPURE:
Questi costi devono essere nella stessa unità di |
costs_ |
Indici dei veicoli a cui si applica |
pickup_ |
Specifica il tempo di deviazione assoluto massimo rispetto al percorso più breve dal ritiro alla consegna. Se specificato, deve essere non negativo e la spedizione deve contenere almeno un ritiro e una consegna. Ad esempio, supponiamo che t sia il tempo più breve necessario per passare dall'opzione di ritiro selezionata direttamente all'opzione di consegna selezionata. L'impostazione
Se nella stessa spedizione vengono specificati sia i limiti relativi che quelli assoluti, viene utilizzato il limite più restrittivo per ogni possibile coppia di ritiro/consegna. A partire da ottobre 2017, i percorsi alternativi sono supportati solo quando le durate dei viaggi non dipendono dai veicoli. |
pickup_ |
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. Ciò non dipende dalle alternative selezionate per il ritiro e la consegna né dalla velocità del veicolo. Questo può essere specificato insieme ai vincoli di deviazione massima: la soluzione rispetterà entrambe le specifiche. |
shipment_ |
Stringa non vuota che specifica un "tipo" per questa spedizione. Questa funzionalità può essere utilizzata per definire incompatibilità o requisiti tra È diverso da |
label |
Specifica un'etichetta per questa spedizione. Questa etichetta viene riportata nella risposta in |
ignore |
Se il valore è true, salta questa spedizione, ma non applica un Se ignori una spedizione, si verifica un errore di convalida se nel modello sono presenti È consentito ignorare una spedizione eseguita in |
penalty_ |
Se la spedizione non viene completata, questa penale viene aggiunta al costo complessivo dei percorsi. Una spedizione è considerata completata se viene visitata una delle alternative di ritiro e consegna. Il costo può essere espresso nella stessa unità utilizzata per tutti gli altri campi relativi ai costi del modello e deve essere positivo. IMPORTANTE: se questa penale non è specificata, è considerata infinita, ovvero la spedizione deve essere completata. |
pickup_ |
Specifica il tempo di deviazione massimo rispetto al percorso più breve dal ritiro alla consegna. Se specificato, deve essere non negativo e la spedizione deve contenere almeno un ritiro e una consegna. Ad esempio, supponiamo che t sia il tempo più breve necessario per passare dall'opzione di ritiro selezionata direttamente all'opzione di consegna selezionata. L'impostazione
Se nella stessa spedizione vengono specificati sia i limiti relativi che quelli assoluti, viene utilizzato il limite più restrittivo per ogni possibile coppia di ritiro/consegna. A partire da ottobre 2017, i percorsi alternativi sono supportati solo quando le durate dei viaggi non dipendono dai veicoli. |
Carica
Quando esegui una visita, al carico del veicolo può essere aggiunto un importo predefinito se si tratta di un ritiro o sottratto se si tratta di una consegna. Questo messaggio definisce l'importo. Leggi i load_demands
.
Campi | |
---|---|
amount |
L'entità del carico del veicolo che esegue la visita corrispondente varierà. 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 effettuata da un veicolo: ha una geolocalizzazione (o due, vedi di seguito), orari di apertura e chiusura rappresentati da finestre temporali e una durata del servizio (tempo impiegato dal veicolo una volta arrivato per ritirare o consegnare le merci).
Campi | |
---|---|
arrival_ |
La posizione geografica in cui arriva il veicolo quando esegui questa |
arrival_ |
Il waypoint in cui arriva il veicolo quando esegue questa |
departure_ |
La geolocalizzazione da cui parte il veicolo al termine di questo |
departure_ |
Il waypoint da cui il veicolo parte dopo aver completato questa |
tags[] |
Specifica i tag associati alla richiesta di visita. Non sono consentite stringhe vuote o duplicate. |
time_ |
Finestre temporali che limitano l'ora di arrivo in una visita. Tieni presente che un veicolo può partire al di fuori dell'intervallo di tempo di arrivo, ovvero l'ora di arrivo + la durata non devono rientrare in un intervallo di tempo. Ciò può comportare tempi di attesa se il veicolo arriva prima delle 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 al possibile tempo di attesa; vedi |
cost |
Costo per soddisfare questa richiesta di visita su un percorso del veicolo. Questo può essere utilizzato per pagare costi diversi per ogni ritiro o consegna alternativa di una spedizione. Questo costo deve essere nella stessa unità di |
load_ |
Carica le richieste di questa visita. È come il campo |
visit_ |
Specifica i tipi di visita. Questo può essere utilizzato per allocare il tempo aggiuntivo necessario a un veicolo per completare questa visita (vedi Un tipo può essere visualizzato una sola volta. |
label |
Specifica un'etichetta per questo |
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 percorso dei veicoli (somma del costo per tempo totale, del costo per tempo di percorrenza e del costo fisso per tutti i veicoli).
- le penalità per le spedizioni non eseguite.
- il costo della durata globale delle spedizioni
Campi | |
---|---|
shipments[] |
Set di importazioni da eseguire nel modello. |
vehicles[] |
Set di veicoli che possono essere utilizzati per effettuare visite. |
global_ |
Ora di inizio e di fine globale del modello: nessuna ora al di fuori di questo intervallo può essere considerata valida. L'intervallo di tempo del modello deve essere inferiore a un anno, ovvero Quando utilizzi i campi |
global_ |
Se non viene impostato, viene utilizzato il valore predefinito 00:00:00 UTC, 1° gennaio 1971 (ovvero secondi: 31536000, nano: 0). |
global_ |
La "durata globale" del piano complessivo è la differenza tra l'ora di inizio effettiva più antica e l'ora di fine effettiva più recente di tutti i veicoli. Gli utenti possono assegnare un costo per ora a questa quantità per provare a ottimizzare per il completamento più rapido del job, ad esempio. Questo costo deve essere espresso nella stessa unità di |
duration_ |
Specifica le matrici di durata e distanza utilizzate nel modello. Se questo campo è vuoto, verranno utilizzate le distanze di Google Maps o geodesiche, a seconda del valore del campo Esempi di utilizzo:
|
duration_ |
Tag che definiscono le origini delle matrici di durata e distanza; I tag corrispondono a |
duration_ |
Tag che definiscono le destinazioni delle matrici di durata e distanza; I tag corrispondono a |
transition_ |
Attributi di transizione aggiunti al modello. |
shipment_ |
Insiemi di tipi di spedizione incompatibili (vedi |
shipment_ |
Insiemi di requisiti |
precedence_ |
Set di regole di precedenza che devono essere applicate nel modello. |
max_ |
Limita il numero massimo di veicoli attivi. Un veicolo è attivo se il suo percorso prevede almeno una spedizione. Questo può essere utilizzato per limitare il numero di percorsi nel caso in cui i conducenti siano inferiori ai veicoli e il parco veicoli sia eterogeneo. L'ottimizzazione selezionerà quindi il sottoinsieme migliore di veicoli da utilizzare. Deve essere strettamente positivo. |
DurationDistanceMatrix
Specifica una matrice di durata e distanza dalle posizioni di partenza e di arrivo del veicolo e delle visite.
Campi | |
---|---|
rows[] |
Specifica le righe della matrice di durata e distanza. Deve contenere lo stesso numero di elementi di |
vehicle_ |
Tag che definisce a quali veicoli si applica questa matrice di durata e distanza. Se è vuoto, si applica a tutti i veicoli e può essere presente una sola matrice. Ogni inizio del viaggio del veicolo deve corrispondere esattamente a una matrice, ovvero esattamente uno dei suoi 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 nel modello non sono presenti costi o vincoli che fanno riferimento alle distanze, questo campo può essere lasciato vuoto; in caso contrario, deve contenere lo stesso numero di elementi di |
PrecedenceRule
Una regola di precedenza tra due eventi (ogni evento è il ritiro o la consegna di una spedizione): l'evento "secondo" deve iniziare almeno offset_duration
dopo l'inizio dell'evento "primo".
Più precedenze possono fare riferimento agli stessi eventi (o correlati), ad esempio "Il ritiro di B avviene dopo la consegna di A" e "Il ritiro di C avviene dopo il ritiro di B".
Inoltre, le precedenze si applicano solo quando vengono eseguite entrambe le importazioni e vengono ignorate in caso contrario.
Campi | |
---|---|
first_ |
Indica se l'evento "primo" è una pubblicazione. |
second_ |
Indica se l'evento "secondo" è una pubblicazione. |
offset_ |
Lo sfasamento tra l'evento "first" e l'evento "second". Può essere negativo. |
first_ |
Indice di spedizione dell'evento "primo". Questo campo deve essere specificato. |
second_ |
Indice di spedizione dell'evento "secondo". Questo campo deve essere specificato. |
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 | | | | ||
|| | | | | | | ||
--++-----------------------------------------------------------------++-->
Campi | |
---|---|
vehicle_ |
Veicolo che esegue il percorso, identificato dal relativo indice nell'origine |
vehicle_ |
Etichetta del veicolo che esegue questo percorso, uguale a |
vehicle_ |
Ora in cui il veicolo inizia il percorso. |
vehicle_ |
Ora in cui il veicolo termina il percorso. |
visits[] |
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[] |
Elenco ordinato delle transizioni per il percorso. |
has_ |
Quando
L'arrivo a next_visit avverrà probabilmente più tardi rispetto all'attuale finestra temporale a causa dell'aumento della stima del tempo di percorrenza |
route_ |
La rappresentazione polilinea codificata del percorso. Questo campo viene compilato solo se |
breaks[] |
Soste programmate per il veicolo che esegue questo percorso. La sequenza |
metrics |
Metriche relative a durata, distanza e carico per questo percorso. I campi di |
route_ |
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. |
route_ |
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_ |
Ora di inizio di un'interruzione. |
duration |
Durata di una pausa. |
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.
Campi | |
---|---|
points |
Stringa che rappresenta i punti codificati del polilinea. |
Transizione
Transizione tra due eventi sul percorso. Consulta la descrizione di ShipmentRoute
.
Se il veicolo non ha start_location
e/o end_location
, le metriche relative ai viaggi corrispondenti sono pari a 0.
Campi | |
---|---|
travel_ |
Durata del viaggio durante questa transizione. |
travel_ |
Distanza percorsa durante la transizione. |
traffic_ |
Quando il traffico viene richiesto tramite |
delay_ |
Somma delle durate dei ritardi applicati a questa transizione. Se presente, il ritardo inizia esattamente |
break_ |
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 |
wait_ |
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. |
total_ |
Durata totale della transizione, fornita per praticità. È uguale a:
|
start_ |
Ora di inizio di questa transizione. |
route_ |
La rappresentazione polilinea codificata del percorso seguito durante la transizione. Questo campo viene compilato solo se |
route_ |
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 |
vehicle_ |
Carichi del veicolo durante questa transizione, per ogni tipo che compare in I carichi durante la prima transizione sono i carichi iniziali del percorso del veicolo. Dopo ogni visita, i valori |
VehicleLoad
Indica il carico effettivo del veicolo in un determinato punto del percorso, per un determinato tipo (vedi Transition.vehicle_loads
).
Campi | |
---|---|
amount |
La quantità di carico sul veicolo, per il tipo specificato. La unità di carico è in genere indicata dal tipo. Leggi i |
Visita
Una visita effettuata durante un percorso. Questa visita corrisponde al ritiro o alla consegna di un Shipment
.
Campi | |
---|---|
shipment_ |
Indice del campo |
is_ |
Se true, la visita corrisponde al ritiro di un |
visit_ |
Indice di |
start_ |
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 |
load_ |
Domanda di carico delle visite totale come somma della spedizione e della richiesta di visita |
detour |
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:
In caso contrario, viene calcolato dal veicolo
|
shipment_ |
Copia del |
visit_ |
Copia del |
ShipmentTypeIncompatibility
Specifica le incompatibilità tra le spedizioni a seconda del relativo shipment_type. La visualizzazione di spedizioni incompatibili sullo stesso percorso è limitata in base alla modalità di incompatibilità.
Campi | |
---|---|
types[] |
Elenco di tipi incompatibili. Due spedizioni con |
incompatibility_ |
Modalità applicata all'incompatibilità. |
IncompatibilityMode
Modalità che definiscono in che modo 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 |
Per due importazioni con tipi incompatibili con la modalità di incompatibilità
|
ShipmentTypeRequirement
Specifica i requisiti tra le spedizioni in base al relativo tipo di spedizione (shipment_type). Le specifiche del requisito sono definite dalla modalità del requisito.
Campi | |
---|---|
required_ |
Elenco dei tipi di spedizione alternativi richiesti dal |
dependent_ |
Tutte le spedizioni con un tipo nel campo NOTA: non sono consentite catene di requisiti in cui un |
requirement_ |
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 "obbligatorie". |
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, tranne che le spedizioni "dipendenti" devono avere una spedizione "obbligatoria" sul veicolo al momento della consegna. |
SkippedShipment
Specifica i dettagli delle importazioni non eseguite in una soluzione. Per i casi banali e/o se siamo in grado di identificare la causa dell'interruzione, 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 ignorata. Vedi il commento sopra |
Motivo
Se possiamo spiegare il motivo per cui la spedizione è stata saltata, i motivi verranno elencati qui. Se il motivo non è lo stesso per tutti i veicoli, reason
avrà più di un elemento. Una spedizione saltata non può avere motivi duplicati, ovvero tutti i campi sono uguali tranne 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à "Mela" di almeno un veicolo verrà superata (incluso il veicolo 1), la capacità "Pera" di almeno un veicolo verrà superata (incluso il veicolo 3) e il limite di distanza di almeno un veicolo verrà superato (incluso il veicolo 1).
Campi | |
---|---|
code |
Fai riferimento ai commenti del codice. |
example_ |
Se il codice del motivo è |
example_ |
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 significato. In particolare, non fornisce alcuna indicazione se un determinato motivo verrà visualizzato prima di un altro nella soluzione, se entrambi si applicano.
Enum | |
---|---|
CODE_UNSPECIFIED |
Questo valore non deve mai essere utilizzato. |
NO_VEHICLE |
Non è presente alcun veicolo nel modello, il che rende non possibili tutte le spedizioni. |
DEMAND_EXCEEDS_VEHICLE_CAPACITY |
La richiesta della spedizione supera la capacità di un veicolo per alcuni tipi di capacità, tra cui example_exceeded_capacity_type . |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DISTANCE_LIMIT |
La distanza minima necessaria per effettuare questa spedizione, ovvero dalla Tieni presente che per questo calcolo utilizziamo le distanze geodetiche. |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT |
Il tempo minimo necessario per effettuare questa spedizione, inclusi i tempi di percorrenza, di attesa e di servizio, supera il Nota: il tempo di percorrenza viene calcolato nello scenario migliore, ovvero come distanza geodetica x 36 m/s (circa 130 km/h). |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TRAVEL_DURATION_LIMIT |
Come sopra, ma viene confrontato solo il tempo di percorrenza minimo e il travel_duration_limit del veicolo. |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TIME_WINDOWS |
Il veicolo non può effettuare questa spedizione nello scenario migliore (vedi CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT per il calcolo del tempo) se parte all'ora di inizio più anticipata: il tempo totale farebbe terminare il viaggio del veicolo dopo la sua ora di fine più tardiva. |
VEHICLE_NOT_ALLOWED |
Il campo allowed_vehicle_indices della spedizione non è vuoto e questo veicolo non vi appartiene. |
TimeWindow
Le finestre temporali limitano l'ora 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 della finestra temporale rigidi, start_time
e end_time
, impongono l'ora iniziale e finale 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 verifichi a partire dal giorno soft_start_time
o in una data successiva, con un costo proporzionale al tempo che intercorre prima dell'evento soft_start_time. Il limite superiore della finestra temporale flessibile, soft_end_time
, esprime una preferenza per la data e l'ora in cui si verifica l'evento, ovvero prima del giorno soft_end_time
, comportando un costo proporzionale al tempo che intercorre dopo questa data.soft_end_time
start_time
, end_time
, soft_start_time
e soft_end_time
devono rispettare i 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_ |
L'ora di inizio dell'intervallo di tempo obbligatorio. Se non specificato, verrà impostato su |
end_ |
L'ora di fine dell'intervallo di tempo obbligatorio. Se non specificato, verrà impostato su |
soft_ |
L'ora di inizio graduale della finestra temporale. |
soft_ |
L'ora di fine flessibile dell'intervallo di tempo. |
cost_ |
Un costo per ora aggiunto agli altri costi nel modello se l'evento si verifica prima di soft_start_time, calcolato come segue:
Questo costo deve essere positivo e il campo può essere impostato solo se è stato impostato soft_start_time. |
cost_ |
Un costo per ora aggiunto agli altri costi del modello se l'evento si verifica dopo
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. Più TransitionAttributes
possono essere applicati alla stessa transizione: in questo caso, tutti i costi aggiuntivi si sommano e si applica la limitazione o il vincolo più rigoroso (secondo la semantica naturale "AND").
Campi | |
---|---|
src_ |
Tag che definiscono l'insieme di transizioni (src->dst) a cui si applicano questi attributi. Una visita o un inizio del viaggio dell'origine corrisponde se e solo se |
excluded_ |
Leggi i |
dst_ |
Una visita alla destinazione o una fine del viaggio corrisponde se e solo se |
excluded_ |
Leggi i |
cost |
Specifica un costo per l'esecuzione di questa transizione. Si tratta della stessa unità di misura di tutti gli altri costi del modello e non deve essere negativo. Viene applicato a tutti gli altri costi esistenti. |
cost_ |
Specifica un costo per chilometro applicato alla distanza percorsa durante l'esecuzione di questa transizione. Si somma a qualsiasi |
distance_ |
Specifica un limite alla distanza percorsa durante l'esecuzione di questa transizione. A partire da giugno 2021, sono supportati solo i limiti flessibili. |
delay |
Specifica un ritardo durante l'esecuzione di questa transizione. Questo ritardo si verifica sempre dopo il completamento della visita di origine e prima dell'inizio della visita di destinazione. |
Veicolo
Modella un veicolo con un problema di spedizione. La risoluzione di un problema di spedizione comporterà la creazione di un percorso che parte da start_location
e termina a end_location
per questo veicolo. Un percorso è una sequenza di visite (vedi ShipmentRoute
).
Campi | |
---|---|
display_ |
Il nome visualizzato del veicolo definito dall'utente. Può contenere fino a 63 caratteri e può utilizzare caratteri UTF-8. |
travel_ |
La modalità di viaggio che influisce sulle strade utilizzabili dal veicolo e sulla sua velocità. Vedi anche |
route_ |
Un insieme di condizioni da soddisfare che influiscono sul modo in cui vengono calcolati i percorsi per il veicolo in questione. |
start_ |
Posizione geografica in cui il veicolo parte prima di ritirare le spedizioni. Se non specificato, il veicolo si avvia al primo ritiro. Se il modello di spedizione ha matrici di durata e distanza, |
start_ |
Waypoint che rappresenta una posizione geografica in cui il veicolo parte prima di ritirare le spedizioni. Se non viene specificato né |
end_ |
Posizione geografica in cui termina il viaggio del veicolo dopo aver completato l'ultima |
end_ |
Waypoint che rappresenta una posizione geografica in cui il veicolo termina dopo aver completato l'ultima |
start_ |
Specifica i tag collegati all'inizio del percorso del veicolo. Non sono consentite stringhe vuote o duplicate. |
end_ |
Specifica i tag collegati alla fine del percorso del veicolo. Non sono consentite stringhe vuote o duplicate. |
start_ |
Fasce orarie durante le quali il veicolo può partire dalla stazione di partenza. Devono rispettare i limiti di tempo globali (vedi 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_ |
Fasce orarie durante le quali il veicolo potrebbe arrivare alla sua destinazione finale. Devono rispettare i limiti di tempo globali (vedi 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_ |
Criterio di scarico applicato al veicolo. |
load_ |
Capacità del veicolo (ad es. peso, volume, numero di pallet). Le chiavi nella mappa sono gli identificatori del tipo di caricamento, in linea con le chiavi del campo |
cost_ |
Costi del veicolo: tutti i costi si sommano e devono essere nella stessa unità di Costo per ora del percorso del veicolo. Questo costo viene applicato al tempo totale impiegato per il percorso e include il tempo di percorrenza, il tempo di attesa e il tempo di visita. L'utilizzo di |
cost_ |
Costo per ora di percorrenza del percorso del veicolo. Questo costo viene applicato solo al tempo di percorrenza del percorso (ovvero quello indicato in |
cost_ |
Costo per chilometro del percorso del veicolo. Questo costo si applica alla distanza indicata nel |
fixed_ |
Costo fisso applicato se questo veicolo viene utilizzato per gestire una spedizione. |
used_ |
Questo campo si applica ai veicoli solo quando il loro percorso non serve spedizioni. Indica se in questo caso il veicolo deve essere considerato usato o meno. Se true, il veicolo si sposta dalla posizione di partenza a quella di destinazione anche se non effettua consegne e vengono presi in considerazione i costi di tempo e distanza derivanti dal viaggio da inizio a fine. In caso contrario, non si sposta dalla stazione di partenza a quella di arrivo e non sono programmati |
route_ |
Limite applicato alla durata totale del percorso del veicolo. In un determinato |
travel_ |
Limite applicato alla durata del viaggio del percorso del veicolo. In un determinato |
route_ |
Limite applicato alla distanza totale del percorso del veicolo. In un determinato |
extra_ |
Specifica una mappa dalle stringhe visit_types alle durate. La durata è il tempo aggiuntivo di Se una richiesta di visita ha più tipi, nella mappa verrà aggiunta una durata per ogni tipo. |
break_ |
Descrive la programmazione delle interruzioni da applicare a questo veicolo. Se è vuoto, non verranno pianificate interruzioni per questo veicolo. |
label |
Specifica un'etichetta per questo veicolo. Questa etichetta viene riportata nella risposta come |
ignore |
Se il valore è true, Se una spedizione viene eseguita da un veicolo ignorato in Se una spedizione viene eseguita da un veicolo ignorato in |
travel_ |
Specifica un fattore moltiplicativo che può essere utilizzato per aumentare o diminuire i tempi di percorrenza di questo veicolo. Ad esempio, se imposti questo valore su 2,0, il veicolo è più lento e i tempi di percorrenza sono il doppio di quelli dei veicoli standard. Questo moltiplicatore non influisce sulle durate delle visite. Influisce sul costo se vengono specificati AVVERTENZA: i tempi di percorrenza verranno arrotondati al secondo più vicino dopo l'applicazione di questo moltiplicatore, ma prima di eseguire qualsiasi operazione numerica. Pertanto, un piccolo moltiplicatore potrebbe comportare una perdita di precisione. Vedi anche |
DurationLimit
Un limite che definisce una durata massima del percorso di un veicolo. Può essere dura o morbida.
Quando viene definito un campo di limite flessibile, devono essere definiti insieme sia la soglia massima flessibile sia il relativo costo.
Campi | |
---|---|
max_ |
Un limite massimo che impone che la durata non superi max_duration. |
soft_ |
Un limite flessibile che non applica un limite di durata massima, ma che, se violato, fa sì che il percorso comporti un costo. Questo costo si somma agli altri costi definiti nel modello, con la stessa unità di misura. Se definito, |
quadratic_ |
Un limite flessibile che non applica un limite di durata massima, ma che, se violato, fa sì che il percorso comporti un costo quadratico in base alla durata. Questo costo si somma agli altri costi definiti nel modello, con la stessa unità di misura. Se definito,
|
cost_ |
Costo orario sostenuto se viene violata la soglia
Il costo deve essere non negativo. |
cost_ |
Costo per ora quadrata 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 fino a 3500 kg". Leggi i load_limits
.
Campi | |
---|---|
soft_ |
Un limite flessibile del carico. Leggi i |
cost_ |
Se il carico supera |
start_ |
L'intervallo di carico accettabile del veicolo all'inizio del percorso. |
end_ |
L'intervallo di carico accettabile del veicolo alla fine del percorso. |
max_ |
La quantità massima di carico accettabile. |
Intervallo
Intervallo di importi di carico accettabili.
Campi | |
---|---|
min |
Un carico minimo accettabile. Deve essere ≥ 0. Se sono specificati entrambi, |
max |
Un carico massimo accettabile. Deve essere ≥ 0. Se non specificato, il carico massimo non è limitato da questo messaggio. Se sono specificati entrambi, |
TravelMode
Modalità di viaggio che possono essere utilizzate dai veicoli.
Devono essere un sottoinsieme dei modi di viaggio dell'API Routes Preferred della piattaforma Google Maps, consulta: https://developers.google.com/maps/documentation/routes_preferred/reference/rest/Shared.Types/RouteTravelMode.
Enum | |
---|---|
TRAVEL_MODE_UNSPECIFIED |
Modalità di viaggio non specificata, equivalente a DRIVING . |
DRIVING |
Modalità di viaggio corrispondente alle indicazioni stradali (auto, ...). |
WALKING |
Modalità di viaggio corrispondente alle indicazioni stradali a piedi. |
UnloadingPolicy
Norme su come un veicolo può essere scaricato. Si applica solo alle spedizioni che prevedono sia il ritiro che la consegna.
Le altre spedizioni possono avvenire in qualsiasi punto del percorso, indipendentemente da unloading_policy
.
Enum | |
---|---|
UNLOADING_POLICY_UNSPECIFIED |
Norme di scarico non specificate: le consegne devono avvenire solo dopo i relativi ritiri. |
LAST_IN_FIRST_OUT |
Le consegne devono avvenire nell'ordine inverso dei ritiri |
FIRST_IN_FIRST_OUT |
Le consegne devono avvenire nello stesso ordine dei ritiri |
Waypoint
Incapsula un waypoint. I waypoint contrassegnano le posizioni di arrivo e partenza delle richieste di visita e le posizioni di partenza e di arrivo dei veicoli.
Campi | |
---|---|
side_ |
Facoltativo. Indica che la posizione di questo waypoint è destinata a avere una preferenza per la fermata del veicolo su un determinato lato della strada. Quando imposti questo valore, il percorso passerà attraverso la località in modo che il veicolo possa fermarsi sul lato della strada verso cui è inclinata la località rispetto al centro della strada. Questa opzione non funziona per la modalità di viaggio "A PIEDI". |
Campo unione location_type . Diversi modi per rappresentare una località. location_type può essere solo uno dei seguenti: |
|
location |
Un punto specificato utilizzando le coordinate geografiche, inclusa un'intestazione facoltativa. |
place_ |
L'ID luogo PDI associato al waypoint. |