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)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 ottimizzare i tour dei veicoli.
Validità di alcuni tipi di campi:
google.protobuf.Timestamp
- Le ore sono espresse in tempo Unix: secondi dal 1970-01-01T00:00:00+00:00.
- i secondi devono essere in [0, 253402300799], ovvero in [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
- i nano non devono essere impostati o devono essere impostati su 0.
google.protobuf.Duration
- i secondi devono essere in [0, 253402300799], ovvero in [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
- i nano non devono essere impostati o devono essere impostati su 0.
google.type.LatLng
- la latitudine deve essere [-90.0, 90.0].
- la longitudine deve essere [-180.0, 180.0].
- almeno uno dei valori di 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 (
|
OptimizeTours |
---|
Invia un Un modello L'obiettivo è fornire un'assegnazione di
|
AggregatedMetrics
Metriche aggregate per ShipmentRoute
(o per OptimizeToursResponse
in tutti gli elementi Transition
e/o Visit
(o su tutti i ShipmentRoute
).
Campi | |
---|---|
performed_shipment_count |
Numero di spedizioni effettuate. 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 |
Durata totale dell'attesa per un percorso o una soluzione. |
delay_duration |
Durata totale del ritardo per un percorso o una soluzione. |
break_duration |
Durata totale dell'interruzione per una route o una soluzione. |
visit_duration |
Durata totale della visita per un percorso o una soluzione. |
total_duration |
La durata totale deve essere uguale alla somma di tutte le durate riportate sopra. Per le route, corrisponde anche a:
|
travel_distance_meters |
Distanza totale da percorrere per un percorso o una soluzione. |
max_loads |
Carico massimo raggiunto sull'intero percorso (risp. soluzione), per ciascuna delle quantità su questa route (risp. soluzione), calcolato come il massimo su tutte le |
BatchOptimizeToursMetadata
Questo tipo non contiene campi.
Metadati delle operazioni per le chiamate BatchOptimizeToursRequest
.
BatchOptimizeToursRequest
Richiesta di ottimizzazione in blocco dei tour come operazione asincrona. Ogni file di input deve contenere un OptimizeToursRequest
e ogni file di output conterrà un file 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. Scegli il progetto e la località di destinazione per effettuare una chiamata. Formato: * Se non viene specificata alcuna località, verrà scelta automaticamente una regione. |
model_configs[] |
Obbligatorio. Informazioni di input/output per ogni modello di acquisto, ad esempio percorsi di 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 dagli utenti come alias per tenere traccia dei modelli. |
input_config |
Obbligatorio. Informazioni sul modello di input. |
output_config |
Obbligatorio. Le informazioni sulla posizione di output desiderate. |
BatchOptimizeToursResponse
Questo tipo non contiene 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 corrente e non può effettuare alcuna visita. Potrebbe verificarsi una pausa:
- durante il viaggio tra due visite (che include il tempo immediatamente prima o subito dopo una visita, ma non nel corso di una visita), nel qual caso estende il tempo di transito corrispondente tra una visita e l'altra;
- o prima dell'avvio del veicolo (il veicolo potrebbe non avviarsi nel bel mezzo di una pausa), nel qual caso l'operazione non influisce sull'ora di inizio del veicolo.
- o dopo la fine del veicolo (come l'ora di fine del veicolo).
Campi | |
---|---|
break_requests[] |
Sequenza delle interruzioni. Leggi il messaggio di |
frequency_constraints[] |
Potrebbero essere applicati diversi |
BreakRequest
La sequenza delle interruzioni (numero e ordine) applicabili a ciascun veicolo deve essere nota in anticipo. I valori BreakRequest
ripetuti definiscono questa sequenza, nell'ordine in cui devono verificarsi. Le finestre temporali (earliest_start_time
/ latest_start_time
) potrebbero sovrapporsi, ma devono essere compatibili con l'ordine (questa informazione è selezionata).
Campi | |
---|---|
earliest_start_time |
Obbligatorio. Limite inferiore (compreso) all'inizio dell'interruzione. |
latest_start_time |
Obbligatorio. Limite superiore (incluso) all'inizio dell'interruzione. |
min_duration |
Obbligatorio. Durata minima della pausa. Deve essere positivo. |
FrequencyConstraint
Si può inoltre limitare la frequenza e la durata delle pause specificate sopra, applicando una frequenza minima delle interruzioni, come ad esempio "È necessaria una pausa di almeno 1 ora ogni 12 ore". Supponendo che possa essere interpretato come "In una finestra temporale scorrevole di 12 ore, deve esserci almeno un'interruzione 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).
}
I tempi e la durata delle interruzioni 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 alle interruzioni non consecutive. Ad esempio, la programmazione seguente rispetta l'"1 h ogni 12 h" esempio:
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. Vedi la descrizione di |
max_inter_break_duration |
Obbligatorio. Periodo massimo consentito di qualsiasi intervallo di tempo del percorso che non include almeno una pausa parziale 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 (JavaScript Object Notation). |
PROTO_TEXT |
Formato di testo dei buffer di protocollo. Vedi https://protobuf.dev/reference/protobuf/textformat-spec/ |
DistanceLimit
Un limite che definisce la distanza massima percorribile. Può essere difficile o morbida.
Se viene definito un limite flessibile, devono essere definiti sia soft_max_meters
sia cost_per_kilometer_above_soft_max
e non devono essere negativi.
Campi | |
---|---|
max_meters |
Un limite rigido che vincola la distanza al massimo a max_meters. Il limite non deve essere negativo. |
soft_max_meters |
Un limite flessibile non applica un limite massimo per la distanza, ma se violato genera un costo che si somma ad altri costi definiti nel modello, con la stessa unità. Se definito soft_max_meters deve essere minore di max_meters e deve essere un numero non negativo. |
cost_per_kilometer_above_soft_max |
Costo per chilometro sostenuto se la distanza supera il limite di
Il costo non deve essere negativo. |
GcsDestination
Il percorso di Google Cloud Storage in cui verranno scritti i file di output.
Campi | |
---|---|
uri |
Obbligatorio. URI Google Cloud Storage. |
GcsSource
Il percorso di Google Cloud Storage da cui verrà letto il file di input.
Campi | |
---|---|
uri |
Obbligatorio. URI di un oggetto Google Cloud Storage nel formato |
InjectedSolutionConstraint
Soluzione inserita nella richiesta, comprese informazioni su quali visite devono essere vincolate e come devono essere vincolate.
Campi | |
---|---|
routes[] |
Route della soluzione da inserire. Alcuni percorsi potrebbero essere omessi dalla soluzione originale. I percorsi e le spedizioni saltate devono soddisfare i presupposti di validità di base elencati per |
skipped_shipments[] |
Sono state saltate le spedizioni della soluzione da inserire. Alcune potrebbero essere omesse dalla soluzione originale. Visualizza 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 non vuoti dei veicoli sono completamente vincolati. |
ConstraintRelaxation
Per un gruppo di veicoli, specifica le soglie da cui applicare i vincoli per le visite e a quale livello. Le spedizioni elencate nel campo skipped_shipment
sono limitate a essere ignorate. ovvero non possono essere eseguite.
Campi | |
---|---|
relaxations[] |
Tutti gli allentamenti dei vincoli di visita che verranno applicati alle visite sui percorsi con veicoli nel seguente periodo: |
vehicle_indices[] |
Specifica gli indici dei veicoli a cui si applica il vincolo di visita Un indice di veicoli viene mappato come |
Relax
Se il campo relaxations
è vuoto, l'ora di inizio e la sequenza di tutte le visite in data routes
sono completamente limitate 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 limitata, a meno che il veicolo non sia vuoto (ovvero non ha visite e ha used_if_route_is_empty
impostato su false nel modello).
relaxations(i).level
specifica il livello di riduzione del vincolo applicato a una visita #j che soddisfa:
route.visits(j).start_time >= relaxations(i).threshold_time
Ej + 1 >= relaxations(i).threshold_visit_count
Allo stesso modo, l'avvio del veicolo viene spostato su relaxations(i).level
se soddisfa:
vehicle_start_time >= relaxations(i).threshold_time
Erelaxations(i).threshold_visit_count == 0
e la fine del veicolo è in posizionerelaxations(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 relax se una visita soddisfa threshold_visit_count
OPPURE 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
, si applica il livello più informale. Di conseguenza, dall'inizio del veicolo attraverso le visite al percorso per arrivare alla fine del veicolo, il livello di rilassamento diventa più rilassato: cioè, il livello di rilassamento non diminuisce con il progredire del percorso.
I tempi e la sequenza delle visite al percorso che non soddisfano le condizioni di soglia di qualsiasi relaxations
sono completamente limitati e nessuna visita può essere inserita in queste sequenze. Inoltre, se l'inizio o la fine di un veicolo non soddisfa le condizioni di rilassamento, l'ora è fissa, a meno che il veicolo non sia vuoto.
Campi | |
---|---|
level |
Il livello di allentamento del vincolo che si applica quando vengono soddisfatte le condizioni uguali o successive a |
threshold_time |
L'ora a partire dal quale può essere applicato il rilassamento |
threshold_visit_count |
Il numero di visite in corrispondenza delle quali o dopo le quali può essere applicato l'allentamento Se è |
Livello
Esprime i diversi livelli di relax del vincolo applicati a una visita e quelli che seguono quando soddisfa le condizioni di soglia.
L'elenco seguente è in ordine crescente.
Enum | |
---|---|
LEVEL_UNSPECIFIED |
Livello di rilassamento predefinito implicito: nessun vincolo è allentato, ossia tutte le visite sono completamente limitate. Questo valore non deve essere utilizzato esplicitamente in |
RELAX_VISIT_TIMES_AFTER_THRESHOLD |
Le ore di inizio delle visite e quelle dei veicoli saranno meno rigide, ma ciascuna visita rimarrà associata allo stesso veicolo ed è necessario osservare la sequenza delle visite: non è possibile inserire visite tra di loro o prima di queste. |
RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD |
Come RELAX_VISIT_TIMES_AFTER_THRESHOLD , ma anche la sequenza delle visite è più lineare: le visite rimangono semplicemente associate al veicolo. |
RELAX_ALL_AFTER_THRESHOLD |
Come RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD , ma allo stesso tempo il veicolo è più allentato: le visite sono completamente senza costi al momento della soglia o dopo questa soglia e possono potenzialmente non essere eseguite. |
InputConfig
Specifica un input per [BatchOptimizeTours][google.maps.routeconfiguration.v1.Route OptimizationService.BatchOptimizeTours].
Campi | |
---|---|
data_format |
Obbligatorio. Il formato dei dati di input. |
Campo unione source . Obbligatorio. source può essere solo uno dei seguenti: |
|
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 della tappa. |
heading |
L'intestazione 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 discesa. I valori di intestazione possono essere compresi tra 0 e 360, dove 0 indica un'intestazione verso nord, 90 specifica un'intestazione verso est ecc. |
OptimizeToursRequest
Richiesta da inoltrare 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: * Se non viene specificata alcuna località, verrà scelta automaticamente una regione. |
timeout |
Se il timeout è impostato, il server restituisce una risposta prima che il periodo di timeout sia trascorso o che sia stata raggiunta la scadenza del server per le richieste sincrone, a seconda dell'evento che si verifica per primo. Per le richieste asincrone, il server genererà una soluzione (se possibile) prima che sia trascorso il 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 a trovare una prima soluzione simile a una precedente. Il modello è vincolato quando viene creata la prima soluzione. Tutte le spedizioni non effettuate su un itinerario vengono implicitamente saltate nella prima soluzione, ma possono essere effettuate in soluzioni successive. La soluzione deve soddisfare alcuni presupposti di base della validità:
Se la soluzione inserita non è fattibile, non viene necessariamente restituito un errore di convalida e potrebbe invece essere restituito un errore che indica l'inattuabilità. |
injected_solution_constraint |
Limitare l'algoritmo di ottimizzazione a trovare una soluzione finale simile a una soluzione precedente. Questa opzione, ad esempio, può essere utilizzata per bloccare parti di percorsi che sono già stati 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 e potrebbe invece essere restituito un errore che indica l'inattuabilità. |
refresh_details_routes[] |
Se il campo non è vuoto, gli itinerari 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 dal 2020/11, questo campo compila solo le polilinee delle route non vuote e richiede che I campi Questo campo non deve essere utilizzato insieme a
|
interpret_injected_solutions_using_labels |
Se il valore è vero:
Questa interpretazione si applica ai campi Se impostato su true, le etichette delle seguenti categorie devono apparire al massimo una sola volta nella categoria:
Se un La rimozione delle visite ai percorsi o di interi percorsi da una soluzione inserita potrebbe influire sui vincoli impliciti, il che potrebbe portare a cambiamenti nella soluzione, errori di convalida o inattuabilità. 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 compilate nelle risposte |
populate_transition_polylines |
Se impostato su true, le polilinee verranno compilate nella risposta |
allow_large_deadline_despite_interruption_risk |
Se questo criterio è impostato, la richiesta può avere una scadenza (vedi https://grpc.io/blog/deadlines) di massimo 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 percorrere 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 potrebbe essere utilizzata per identificare questa richiesta, riportata nel |
geodesic_meters_per_second |
Se |
max_validation_errors |
Tronca il numero di errori di convalida restituiti. Questi errori in genere sono associati a un payload di errore INVALID_ARGUMENT come dettaglio dell'errore BadRequest (https://cloud.google.com/apis/design/errors#error_details), a meno che non si veda il campo |
SearchMode
Modalità che definisce il comportamento della ricerca, scambiando 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 disponibile alla ricerca di soluzioni migliori. |
SolvingMode
Definisce il modo in cui il risolutore deve gestire la richiesta. In tutte le modalità tranne in VALIDATE_ONLY
, se la richiesta non è valida, riceverai un errore INVALID_REQUEST
. Vedi max_validation_errors
per limitare il numero di errori restituiti.
Enum | |
---|---|
DEFAULT_SOLVE |
Risolvi il modello. |
VALIDATE_ONLY |
Convalida il modello solo senza risolverlo: compila il maggior numero possibile di OptimizeToursResponse.validation_errors . |
DETECT_SOME_INFEASIBLE_SHIPMENTS |
Compila solo IMPORTANTE: qui non vengono restituite tutte le spedizioni non realizzabili, ma solo quelle che vengono rilevate come non eseguibili durante la pre-elaborazione. |
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; 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 "MULTIPLI ERRORI" spiegazione del messaggio |
metrics |
Metriche di durata, distanza e utilizzo per questa soluzione. |
Metriche
Metriche complessive, aggregate per tutti i percorsi.
Campi | |
---|---|
aggregated_route_metrics |
Dati aggregati sulle route. Ogni metrica indica la somma (o il valore massimo per i caricamenti) di tutti i campi |
skipped_mandatory_shipment_count |
Numero di spedizioni obbligatorie saltate. |
used_vehicle_count |
Numero di veicoli utilizzati. Nota: se il percorso di un veicolo è vuoto e il valore |
earliest_vehicle_start_time |
La prima ora di inizio per un veicolo usato, calcolata come minima rispetto a tutti i veicoli usati di |
latest_vehicle_end_time |
L'ora di fine più recente per un veicolo usato, calcolata come la massima per tutti i veicoli usati di |
costs |
Costo della soluzione, suddiviso per campi di richiesta correlati ai costi. Le chiavi sono percorsi di protocollo, rispetto all'input OptimizeToursRequest, ad esempio "model.shipments.pickups.cost" e i valori corrispondono al costo totale generato dal campo di costo corrispondente, aggregato per l'intera soluzione. In altre parole, costi ["model.shipments.pickups.cost"] è la somma di tutti i costi di ritiro rispetto alla 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 dal 2022/01. |
total_cost |
Costo totale della soluzione. La somma di tutti i valori nella mappa dei costi. |
OptimizeToursValidationError
Descrive un errore riscontrato durante la convalida di un OptimizeToursRequest
.
Campi | |
---|---|
code |
Un errore di convalida viene definito dalla coppia ( Gli altri campi (di seguito) forniscono maggiore contesto sull'errore. DIVERSI ERRORI: quando sono presenti più errori, il processo di convalida prova a generarne diversi. Si tratta di un processo imperfetto, proprio come per un compilatore. Alcuni errori di convalida saranno "irreversibili", ovvero interrompono l'intero processo di convalida. Questo è il caso, tra gli altri, di STABILITÀ: RIFERIMENTO: un elenco di tutte le coppie (codice, nome):
|
display_name |
Il nome visualizzato dell'errore. |
fields[] |
Un contesto di errore può includere 0, 1 (la maggior parte delle volte) o più campi. Ad esempio, puoi fare riferimento al veicolo n. 4 e al primo ritiro della spedizione n. 2 nel seguente modo:
Tuttavia, tieni presente 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 dovresti assolutamente fare affidamento su questo prodotto 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 di 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 "veicoli". |
sub_field |
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.routemonetization.v1.Route OptimizationService.BatchOptimizeTours].
Campi | |
---|---|
data_format |
Obbligatorio. Il formato dei dati di output. |
Campo unione destination . Obbligatorio. destination può essere solo uno dei seguenti: |
|
gcs_destination |
Il percorso di Google Cloud Storage in cui scrivere l'output. |
Spedizione
La spedizione di un singolo articolo, da uno dei suoi ritiri a una delle sue consegne. Affinché la spedizione venga considerata eseguita, un veicolo unico deve visitare una delle sedi di ritiro (e diminuire di conseguenza la capacità di riserva), quindi visitare una delle sedi di consegna in un secondo momento (e quindi aumentare di conseguenza la capacità di riserva).
Campi | |
---|---|
display_name |
Il nome visualizzato della spedizione definito dall'utente. Può avere una lunghezza massima di 63 caratteri e possono essere utilizzati caratteri UTF-8. |
pickups[] |
Insieme di alternative per il ritiro associate alla spedizione. Se non specificato, il veicolo deve visitare solo una sede corrispondente alle consegne. |
deliveries[] |
Insieme di alternative di consegna associate alla spedizione. Se non specificato, il veicolo deve visitare solo un luogo corrispondente ai ritiri. |
load_demands |
Carica le esigenze della spedizione (ad es. peso, volume, numero di pallet e così via). Le chiavi nella mappa dovrebbero essere identificatori che descrivono il tipo di carico corrispondente e idealmente includono 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 potrebbero effettuare questa spedizione. Se è vuota, la si può eseguire su tutti i veicoli. I veicoli sono indicati in base al relativo indice nell'elenco |
costs_per_vehicle[] |
Specifica il costo sostenuto quando la spedizione viene consegnata da ciascun veicolo. Se specificato, deve contenere CIASCUNO:
Questi costi devono essere 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 massimo assoluto rispetto al percorso più breve dal prelievo alla consegna. Se specificato, non deve essere negativo e la spedizione deve contenere almeno un ritiro e una consegna. Ad esempio, lascia che sia il tempo più breve necessario per passare direttamente dall'alternativa di ritiro selezionata a quella selezionata. Quindi, l'impostazione di
Se nella stessa spedizione vengono specificati limiti sia relativi che assoluti, il limite più vincolante viene utilizzato per ogni possibile coppia di ritiro/consegna. A partire dal 2017/10, le deviazioni sono supportate solo quando la durata dei viaggi non dipende dai veicoli. |
pickup_to_delivery_time_limit |
Specifica la durata massima dall'inizio del ritiro all'inizio della consegna di una spedizione. Se specificato, non deve essere 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 massimi di deviazione: la soluzione rispetterà entrambe le specifiche. |
shipment_type |
Stringa non vuota che specifica un "type" per questa spedizione. Questa funzionalità può essere utilizzata per definire incompatibilità o requisiti tra il giorno Differisce dal valore |
label |
Specifica un'etichetta per questa spedizione. Questa etichetta è riportata nella risposta nel campo |
ignore |
In questo caso, salta questa spedizione, ma non applicare un Se ignori una spedizione, il modello restituisce un errore di convalida se il modello include È consentito ignorare una spedizione effettuata nei seguenti paesi: |
penalty_cost |
Se la spedizione non viene completata, questa penale viene aggiunta al costo complessivo dei percorsi. Una spedizione viene 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 correlati ai costi nel modello e deve essere positivo. IMPORTANTE: se questa sanzione non viene specificata, è considerata infinita, ovvero la spedizione deve essere completata. |
pickup_to_delivery_relative_detour_limit |
Specifica il tempo relativo massimo della deviazione rispetto al percorso più breve dal ritiro alla consegna. Se specificato, non deve essere negativo e la spedizione deve contenere almeno un ritiro e una consegna. Ad esempio, lascia che sia il tempo più breve necessario per passare direttamente dall'alternativa di ritiro selezionata a quella selezionata. Quindi, l'impostazione di
Se nella stessa spedizione vengono specificati limiti sia relativi che assoluti, il limite più vincolante viene utilizzato per ogni possibile coppia di ritiro/consegna. A partire dal 2017/10, le deviazioni sono supportate solo quando la durata dei viaggi non dipende dai veicoli. |
Carica
Quando effettui una visita, un importo predefinito può essere aggiunto al carico del veicolo se si tratta di un ritiro oppure sottratto se si tratta di una consegna. Questo messaggio definisce questo importo. Leggi i load_demands
.
Campi | |
---|---|
amount |
L'entità del carico del veicolo che effettua la visita corrispondente varia. 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 sotto), gli orari di apertura e chiusura rappresentati da finestre temporali e la durata del servizio (tempo trascorso dal veicolo una volta arrivato al ritiro o alla consegna delle merci).
Campi | |
---|---|
arrival_location |
La geolocalizzazione a cui arriva il veicolo quando esegui questo |
arrival_waypoint |
Il waypoint a cui arriva il veicolo quando si esegue questo |
departure_location |
La geolocalizzazione in cui parte il veicolo dopo aver completato questo |
departure_waypoint |
La tappa 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, ad esempio ora di arrivo + durata non devono necessariamente essere all'interno di una finestra temporale. Ciò può comportare dei tempi di attesa se il veicolo arriva prima del giorno L'assenza di Le finestre temporali devono essere separate, ovvero non devono sovrapporsi o essere adiacenti a un'altra e devono essere in ordine crescente.
|
duration |
Durata della visita, ossia il tempo trascorso dal veicolo tra l'arrivo e la partenza (da aggiungere al possibile tempo di attesa; consulta |
cost |
Costo per gestire questa richiesta di visita su un percorso di veicoli. Questa opzione può essere utilizzata per pagare costi diversi per ogni ritiro o consegna alternativa di una spedizione. Questo costo deve essere nella stessa unità di |
load_demands |
Carica le richieste di questa richiesta di visita. È proprio come il campo |
visit_types[] |
Specifica i tipi di visita. In questo modo è possibile 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 l'elemento |
ShipmentModel
Un modello di spedizione contiene un insieme di spedizioni che devono essere effettuate da un insieme di veicoli, riducendo al minimo il costo complessivo, ovvero la somma di:
- Il costo di transito dei veicoli (somma del costo per tempo totale, costo per tempo di percorrenza e costo fisso su tutti i veicoli).
- le penalità di spedizione per mancata esecuzione.
- il costo della durata globale delle spedizioni
Campi | |
---|---|
shipments[] |
Insieme di spedizioni che devono essere effettuate nel modello. |
vehicles[] |
Insieme di veicoli che possono essere utilizzati per effettuare visite. |
global_start_time |
Ora di inizio e di fine globali del modello: nessun orario al di fuori di questo intervallo può essere considerato valido. L'intervallo di tempo del modello deve essere inferiore a un anno, ad esempio Quando utilizzi i campi |
global_end_time |
Se non viene configurato, per impostazione predefinita viene utilizzato il valore 00:00:00 UTC, 1 gennaio 1971 (secondi: 31536000, nano: 0). |
global_duration_cost_per_hour |
La "durata globale" del piano generale è la differenza tra la prima ora di inizio effettiva e l'ultima ora di fine effettiva di tutti i veicoli. Gli utenti possono assegnare un costo orario a quella quantità per provare, ad esempio, a eseguire l'ottimizzazione prima del completamento del lavoro. Questo costo deve essere nella stessa unità di |
duration_distance_matrices[] |
Specifica le matrici di durata e distanza utilizzate nel modello. Se questo campo è vuoto, verrà utilizzato Google Maps o le distanze geodetiche, a seconda del valore del campo Esempi di utilizzo:
|
duration_distance_matrix_src_tags[] |
i tag che definiscono le origini delle matrici di durata e distanza. I tag corrispondono a |
duration_distance_matrix_dst_tags[] |
i tag che definiscono le destinazioni delle matrici di durata e distanza. I tag corrispondono a |
transition_attributes[] |
Attributi di transizione aggiunti al modello. |
shipment_type_incompatibilities[] |
Insiemi di spedizioni_type incompatibili (vedi |
shipment_type_requirements[] |
Insieme di requisiti per |
precedence_rules[] |
Insieme di regole di precedenza che devono essere applicate nel modello. |
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 che il parco veicoli sia eterogeneo. L'ottimizzazione selezionerà quindi il sottoinsieme migliore di veicoli da utilizzare. Deve essere strettamente positiva. |
DurationDistanceMatrix
Specifica una matrice di durata e distanza tra le posizioni delle visite e dei veicoli da visitare e le località di fine dei veicoli.
Campi | |
---|---|
rows[] |
Specifica le righe della durata e della matrice della distanza. Deve avere un numero di elementi pari a |
vehicle_start_tag |
Tag che definisce a quali veicoli si applica la durata e la matrice della distanza. Se vuoto, questo vale per tutti i veicoli e può essere presente una sola matrice. L'inizio di ogni veicolo deve corrispondere esattamente a una matrice, ovvero a uno dei campi Tutte le matrici devono avere un valore |
Riga
Specifica una riga della durata e della matrice della distanza.
Campi | |
---|---|
durations[] |
Valori di durata per una determinata riga. Deve avere un numero di elementi pari a |
meters[] |
Valori di distanza per una determinata riga. Se nessun costo o vincolo si riferisce alle distanze nel modello, questo campo può essere lasciato vuoto; altrimenti deve avere un numero di elementi pari a |
PrecedenceRule
Una regola di precedenza tra due eventi (ogni evento è il ritiro o la consegna di una spedizione): il "secondo" l'evento deve iniziare almeno offset_duration
dopo "primo" è iniziata.
Diverse precedenza possono fare riferimento agli stessi eventi (o correlati), ad esempio "il ritiro di B avviene dopo la consegna di A" mentre "il ritiro di C avviene dopo il ritiro di B".
Inoltre, le priorità si applicano solo quando entrambe le spedizioni vengono effettuate e vengono altrimenti ignorate.
Campi | |
---|---|
first_is_delivery |
Indica se il "primo" è un caricamento. |
second_is_delivery |
Indica se il "secondo" è un caricamento. |
offset_duration |
L'offset tra il "primo" e "second" . Può essere negativo. |
first_index |
Indice di spedizione del "primo" . Questo campo è obbligatorio. |
second_index |
Indice di spedizione del "secondo" . Questo campo è obbligatorio. |
ShipmentRoute
Il percorso di un veicolo può essere scomposto lungo l'asse del tempo, in questo modo (supponiamo che ci siano n visite):
| | | | | T[2], | | |
| Transition | Visit #0 | | | V[2], | | |
| #0 | aka | T[1] | V[1] | ... | V[n-1] | T[n] |
| aka T[0] | V[0] | | | V[n-2],| | |
| | | | | T[n-1] | | |
^ ^ ^ ^ ^ ^ ^ ^
vehicle V[0].start V[0].end V[1]. V[1]. V[n]. V[n]. vehicle
start (arrival) (departure) start end start end end
Facciamo la differenza tra:
- "eventi puntuali", come l'inizio e la fine del veicolo e l'inizio e la fine di ogni visita (ovvero l'arrivo e la partenza). Si verificano in un dato secondo.
- "intervalli di tempo", come le visite stesse e la transizione tra una visita e l'altra. Anche se a volte gli intervalli di tempo possono avere una durata pari a zero, ovvero inizio e fine allo stesso secondo, spesso hanno una durata positiva.
Invarianti:
- Se ci sono n visite, sono presenti n+1 transizioni.
- Una visita è sempre circondata da una transizione precedente (stesso indice) e da una transizione successiva (indice + 1).
- L'avvio del veicolo è sempre seguito dal passaggio 0.
- La fine del veicolo è sempre preceduta dalla transizione #n.
Aumentando lo zoom, ecco cosa succede durante un Transition
e un Visit
:
---+-------------------------------------+-----------------------------+-->
| TRANSITION[i] | VISIT[i] |
| | |
| * TRAVEL: the vehicle moves from | PERFORM the visit: |
| VISIT[i-1].departure_location to | |
| VISIT[i].arrival_location, which | * Spend some time: |
| takes a given travel duration | the "visit duration". |
| and distance | |
| | * Load or unload |
| * BREAKS: the driver may have | some quantities from the |
| breaks (e.g. lunch break). | vehicle: the "demand". |
| | |
| * WAIT: the driver/vehicle does | |
| nothing. This can happen for | |
| many reasons, for example when | |
| the vehicle reaches the next | |
| event's destination before the | |
| start of its time window | |
| | |
| * DELAY: *right before* the next | |
| arrival. E.g. the vehicle and/or | |
| driver spends time unloading. | |
| | |
---+-------------------------------------+-----------------------------+-->
^ ^ ^
V[i-1].end V[i].start V[i].end
Infine, ecco come si può organizzare VIAGGI, PAUSE, RITARDO e ATTESA durante una transizione.
- Non si sovrappongono.
- Il ritardo è univoco e deve essere un periodo di tempo contiguo subito prima della prossima visita (o della fine del veicolo). Pertanto, è sufficiente conoscere la durata del ritardo per conoscere l'ora di inizio e di fine.
- Le interruzioni sono periodi di tempo contigui e non sovrapposti. La risposta specifica l'ora di inizio e la durata di ogni interruzione.
- TRAVEL e WAIT sono "prerilasciabili": possono essere interrotti più volte durante questa transizione. I clienti possono presumere che il viaggio avvenga "il prima possibile" e "attendi" esaurisce il tempo rimanente.
Esempio (complesso):
TRANSITION[i]
--++-----+-----------------------------------------------------------++-->
|| | | | | | | ||
|| T | B | T | | B | | D ||
|| r | r | r | W | r | W | e ||
|| a | e | a | a | e | a | l ||
|| v | a | v | i | a | i | a ||
|| e | k | e | t | k | t | y ||
|| l | | l | | | | ||
|| | | | | | | ||
--++-----------------------------------------------------------------++-->
Campi | |
---|---|
vehicle_index |
Veicolo che esegue il percorso, identificato dal suo indice nella sorgente |
vehicle_label |
Etichetta del veicolo che effettua 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 percorso. |
visits[] |
Sequenza ordinata di visite che rappresenta un percorso. visite[i] indica l'i-esima visita nel percorso. Se questo campo è vuoto, il veicolo è considerato inutilizzato. |
transitions[] |
Elenco ordinato di transizioni per il percorso. |
has_traffic_infeasibilities |
Se il criterio
L'arrivo alla prossima visita probabilmente avverrà dopo la finestra temporale attuale a causa dell'aumento della stima del tempo di percorrenza |
route_polyline |
La rappresentazione codificata della polilinea della route. Questo campo viene compilato solo se il criterio |
breaks[] |
Pause programmate per il veicolo che effettua questo percorso. La sequenza |
metrics |
Metriche relative a durata, distanza e carico per questo percorso. I campi di |
route_costs |
Costo del percorso, suddiviso in base ai campi di richiesta correlati ai costi. Le chiavi sono percorsi di protocollo, rispetto all'input OptimizeToursRequest, ad esempio "model.shipments.pickups.cost" e i valori corrispondono al costo totale generato dal campo di costo corrispondente, aggregato per l'intero percorso. In altre parole, costi ["model.shipments.pickups.cost"] è la somma di tutti i costi di ritiro lungo il percorso. Tutti i costi definiti nel modello sono riportati in dettaglio qui, ad eccezione dei costi relativi a TransitionAttributes che sono riportati solo in modo aggregato a partire dal 2022/01. |
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 una pausa. |
duration |
Durata di una pausa. |
EncodedPolyline
La rappresentazione codificata di una polilinea. Ulteriori informazioni sulla codifica delle polilinee sono disponibili qui: https://developers.google.com/maps/documentation/utilities/polylinealgorithm https://developers.google.com/maps/documentation/javascript/reference/geometry#encoding.
Campi | |
---|---|
points |
Stringa che rappresenta i punti codificati della polilinea. |
Transizione
Transizione tra due eventi lungo il percorso. Vedi la descrizione di ShipmentRoute
.
Se il veicolo non dispone di start_location
e/o end_location
, le metriche di viaggio corrispondenti sono 0.
Campi | |
---|---|
travel_duration |
Durata del viaggio durante questa transizione. |
travel_distance_meters |
Distanza percorsa durante la transizione. |
traffic_info_unavailable |
Se il traffico viene richiesto tramite |
delay_duration |
Somma delle durate del ritardo applicate a questa transizione. Se presente, il ritardo inizia esattamente |
break_duration |
Somma della durata delle pause durante questa transizione, se presente. I dettagli relativi all'ora di inizio e alla durata di ogni interruzione vengono memorizzati in |
wait_duration |
Tempo di attesa durante questa transizione. La durata di attesa corrisponde al tempo di inattività e non include il tempo di pausa. Tieni inoltre presente che questo tempo di attesa può essere suddiviso in diversi intervalli non contigui. |
total_duration |
Durata totale della transizione, fornita per praticità. È uguale a:
|
start_time |
Ora di inizio di questa transizione. |
route_polyline |
La rappresentazione codificata della polilinea del percorso seguito durante la transizione. Questo campo viene compilato solo se il criterio |
vehicle_loads |
Durante questa transizione vengono caricati i veicoli, per ogni tipo presente nell' I carichi durante la prima transizione sono i carichi di partenza del percorso del veicolo. Poi, dopo ogni visita, i |
VehicleLoad
Segnala 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 specifico. L'unità di carico è solitamente indicata dal tipo. Leggi i |
Visita
Una visita effettuata durante un percorso. Questa visita corrisponde a un ritiro o 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 in cui ha inizio la visita. Tieni presente che il veicolo potrebbe arrivare prima di questo nel luogo in cui ti trovi. Gli orari sono in linea con l' |
load_demands |
Domanda totale di caricamento di visite come somma della spedizione e della richiesta di visita |
detour |
Tempo di deviazione extra dovuto alle spedizioni visitate sul percorso prima della visita e ai potenziali tempi di attesa causati da finestre temporali. Se la visita è una consegna, la deviazione viene calcolata in base alla visita di ritiro corrispondente ed è uguale a:
In caso contrario, viene calcolato dal veicolo
|
shipment_label |
Copia del valore |
visit_label |
Copia del valore |
ShipmentTypeIncompatibility
Specifica le incompatibilità tra le spedizioni in base al relativo tipo di spedizione. La comparsa di spedizioni incompatibili sullo stesso percorso è limitata in base alla modalità di incompatibilità.
Campi | |
---|---|
types[] |
Elenco dei tipi incompatibili. Due spedizioni con |
incompatibility_mode |
Modalità applicata all'incompatibilità. |
IncompatibilityMode
Modalità che definiscono le limitazioni di visualizzazione di spedizioni incompatibili 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 spedizioni con tipi incompatibili con la modalità di incompatibilità di
|
ShipmentTypeRequirement
Specifica i requisiti tra le spedizioni in base al relativo tipo di spedizione. Le specifiche dei requisiti sono definite dalla modalità dei requisiti.
Campi | |
---|---|
required_shipment_type_alternatives[] |
Elenco dei tipi di spedizione alternativi richiesti dall' |
dependent_shipment_types[] |
Tutte le spedizioni con un tipo nel campo NOTA: non sono consentite catene di requisiti tali da cui un elemento |
requirement_mode |
Modalità applicata al requisito. |
RequirementMode
Modalità che definiscono l'aspetto di spedizioni dipendenti su un itinerario.
Enum | |
---|---|
REQUIREMENT_MODE_UNSPECIFIED |
Modalità requisito non specificata. Questo valore non deve mai essere utilizzato. |
PERFORMED_BY_SAME_VEHICLE |
In questa modalità, tutti i pod Le spedizioni devono condividere lo stesso veicolo di almeno uno dei valori "obbligatori" spedizioni. |
IN_SAME_VEHICLE_AT_PICKUP_TIME |
Con la modalità Un "dipendente" Il ritiro della spedizione deve quindi avere:
|
IN_SAME_VEHICLE_AT_DELIVERY_TIME |
Come prima, ad eccezione degli elementi "dipendenti" le spedizioni devono avere un "obbligatorio" sulla spedizione del 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 dell'abbandono, riportiamo il motivo qui.
Campi | |
---|---|
index |
L'indice corrisponde a quello della spedizione nell'origine |
label |
Copia del valore |
reasons[] |
Un elenco di motivi che spiegano il motivo per cui la spedizione è stata saltata. Vedi il commento sopra |
Motivo
Se riusciamo a spiegare il motivo per cui la spedizione è stata saltata, i motivi saranno elencati qui. Se il motivo non è lo stesso per tutti i veicoli, reason
conterrà più di un elemento. Una spedizione saltata non può avere motivi duplicati, ad esempio se tutti i campi sono gli stessi 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 potrebbero essere diversi per tutti i veicoli, ma per almeno un veicolo, le "Mele" la capacità massima sarebbe superata (incluso il veicolo 1), la quantità di "Pere" di almeno un veicolo la capacità massima sarebbe superata (compreso il veicolo 3) e il limite di distanza di almeno un veicolo (incluso il veicolo 1).
Campi | |
---|---|
code |
Fai riferimento ai commenti del Codice. |
example_exceeded_capacity_type |
Se il codice motivo è |
example_vehicle_index |
Se il motivo è legato 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 è privo di significato. In particolare, non indica se un determinato motivo apparirà prima di un altro nella soluzione, nel caso in cui entrambi i motivi siano applicabili.
Enum | |
---|---|
CODE_UNSPECIFIED |
Non deve mai essere utilizzato. Se non riusciamo a capire il motivo per cui una spedizione è stata saltata, restituiamo semplicemente una serie di motivi vuoti. |
NO_VEHICLE |
Nessun veicolo nel modello rende non fattibili tutte le spedizioni. |
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, ad esempio 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 viaggio, i tempi di attesa e i tempi di assistenza, supera i 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 i travel_duration_limit del veicolo. |
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TIME_WINDOWS |
Il veicolo non può eseguire questa spedizione nello scenario migliore (vedi CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT per il calcolo dei tempi) se inizia alla prima ora di inizio: il tempo totale farà 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 è di sua proprietà. |
TimeWindow
Le finestre temporali vincolano l'ora di un evento, come l'ora di arrivo di una visita o l'ora di inizio e di fine di un veicolo.
I limiti fissi di finestre temporali, start_time
e end_time
, applicano l'ora più vicina e più recente dell'evento, ad esempio start_time <= event_time <=
end_time
. Il limite inferiore della finestra temporale flessibile, soft_start_time
, esprime una preferenza affinché l'evento si verifichi a partire da soft_start_time
in base a un costo proporzionale al tempo prima che si verifichi soft_start_time l'evento. Il limite superiore della finestra temporale flessibile, soft_end_time
, esprime una preferenza affinché l'evento si verifichi entro il giorno soft_end_time
prevedendo un costo proporzionale al periodo di tempo successivo al giorno soft_end_time
dell'evento. 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` <= `soft_start_time` <= `end_time` and
0 <= `start_time` <= `soft_end_time` <= `end_time`.
Campi | |
---|---|
start_time |
L'ora di inizio della finestra temporale massima. Se non specificato, verrà impostato su |
end_time |
L'ora di fine della finestra temporale massima. Se non specificato, verrà impostato su |
soft_start_time |
L'ora di soft start della finestra temporale. |
soft_end_time |
L'ora di fine soft della finestra temporale. |
cost_per_hour_before_soft_start_time |
Un costo per ora aggiunto ad altri costi nel modello se l'evento si verifica prima del valore 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_per_hour_after_soft_end_time |
Un costo per ora 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. Alla stessa transizione possono essere applicati diversi TransitionAttributes
: in questo caso, tutti i costi aggiuntivi vengono sommati e viene applicato il vincolo o il limite più rigido (secondo la semantica "AND" naturale).
Campi | |
---|---|
src_tag |
I tag che definiscono l'insieme di transizioni (src->dst) a cui si applicano questi attributi. Una visita della sorgente o l'inizio di un veicolo corrisponde a se il suo |
excluded_src_tag |
Leggi i |
dst_tag |
Una visita di destinazione o una fine del veicolo corrisponde se la sua |
excluded_dst_tag |
Leggi i |
cost |
Specifica un costo per l'esecuzione di questa transizione. Questo valore è nella stessa unità di tutti gli altri costi del modello e non deve essere negativo. Viene applicato 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. Viene sommato a qualsiasi |
distance_limit |
Specifica un limite per la distanza percorsa durante l'esecuzione di questa transizione. A partire dal 2021/06, sono supportati solo i limiti software. |
delay |
Specifica il ritardo riscontrato durante l'esecuzione di questa transizione. Questo ritardo si verifica sempre dopo aver terminato la visita di origine e prima di iniziare la visita di destinazione. |
Veicolo
Modella un veicolo in un problema di spedizione. Se risolvi un problema di spedizione, per questo veicolo verrà creato un percorso che parte da start_location
e termina a end_location
. Un percorso è una sequenza di visite (vedi ShipmentRoute
).
Campi | |
---|---|
display_name |
Il nome visualizzato del veicolo definito dall'utente. Può avere una lunghezza massima di 63 caratteri e possono essere utilizzati caratteri UTF-8. |
travel_mode |
La modalità di viaggio che influisce sulle strade percorribili dal veicolo e sulla sua velocità. Vedi anche |
start_location |
La posizione geografica in cui parte il veicolo prima di ritirare qualsiasi spedizione. Se non specificato, il veicolo inizia al primo ritiro. Se il modello di spedizione ha matrici di durata e distanza, non è necessario specificare |
start_waypoint |
Waypoint che rappresenta una posizione geografica in cui il veicolo parte prima di ritirare qualsiasi spedizione. Se non viene specificato né |
end_location |
La posizione geografica in cui termina il veicolo dopo aver completato gli ultimi |
end_waypoint |
Waypoint che rappresenta una posizione geografica in cui il veicolo termina dopo che ha completato l'ultimo |
start_tags[] |
Specifica i tag allegati all'inizio del percorso del veicolo. Non sono consentite stringhe vuote o duplicate. |
end_tags[] |
Specifica i tag allegati 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 posizione di partenza. Devono rientrare nei limiti di tempo globali (vedi i campi Le finestre temporali appartenenti allo stesso campo ripetuto devono essere separate, ossia 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 potrebbe arrivare alla sua posizione di fine. Devono rientrare nei limiti di tempo globali (vedi i campi Le finestre temporali appartenenti allo stesso campo ripetuto devono essere separate, ossia nessuna finestra temporale può sovrapporsi o essere adiacente a un'altra e devono essere in ordine cronologico.
|
unloading_policy |
Criterio di scarico applicato al veicolo. |
load_limits |
Capacità del veicolo (peso, volume, numero di pallet, ad esempio). Le chiavi nella mappa sono gli identificatori del tipo di caricamento, in linea con le chiavi del campo |
cost_per_hour |
Costi del veicolo: tutti i costi vengono sommati e devono essere nella stessa unità di Costo per ora di 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 percorrenza del percorso con il veicolo. Questo costo viene applicato solo al tempo di percorrenza previsto per il percorso (ad es. riportato in |
cost_per_kilometer |
Costo per chilometro del percorso per veicoli. Questo costo viene applicato alla distanza riportata nel |
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 è vero, il veicolo passa dalla sua posizione di partenza a quella di arrivo anche se non effettua alcuna spedizione e i costi in termini di tempo e distanza derivanti dall'inizio --> alla fine del viaggio vengono prese in considerazione. In caso contrario, il veicolo non si sposta dall'inizio alla posizione di fine 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 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, in aggiunta a Se una richiesta di visita ha più tipi, verrà aggiunta una durata per ogni tipo nella mappa. |
break_rule |
Descrive il programma delle interruzioni da applicare su questo veicolo. Se vuoto, non saranno programmate pause per questo veicolo. |
label |
Specifica un'etichetta per questo veicolo. Questa etichetta viene segnalata 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 questo veicolo è più lento e ha tempi di percorrenza due volte superiori rispetto a quelli dei veicoli standard. Questo multiplo non influisce sulla durata delle visite. Ciò influisce sui costi se vengono specificati ATTENZIONE: i tempi di percorrenza saranno arrotondati al secondo più vicino dopo l'applicazione di questo multiplo, ma prima di eseguire qualsiasi operazione numerica; pertanto, un piccolo multiplo può comportare una perdita di precisione. Vedi anche |
DurationLimit
Un limite che definisce la durata massima del percorso di un veicolo. Può essere difficile o morbida.
Quando viene definito un campo del limite flessibile, è necessario definire insieme la soglia massima e il costo associato.
Campi | |
---|---|
max_duration |
Un limite rigido vincola la durata al massimo a max_duration. |
soft_max_duration |
Un limite flessibile che non applica un limite di durata massimo, ma in caso di violazione comporta un costo per la route. Questo costo si somma ad altri costi definiti nel modello, con la stessa unità. Se definito, |
quadratic_soft_max_duration |
Un limite flessibile non applica un limite di durata massimo, ma se viene violato comporta un costo quadratico nella durata. Questo costo si somma ad altri costi definiti nel modello, con la stessa unità. Se definito,
|
cost_per_hour_after_soft_max |
Costo orario sostenuto in caso di violazione della soglia di
Il costo non deve essere negativo. |
cost_per_square_hour_after_quadratic_soft_max |
Costo per ora quadrata in caso di violazione della soglia di Il costo aggiuntivo è pari a 0 se la durata è inferiore alla soglia, altrimenti il costo dipende dalla durata, come segue:
Il costo non deve essere negativo. |
LoadLimit
Definisce un limite di carico applicabile a un veicolo, ad es. "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 accettabile di carico. |
Intervallo
Intervallo delle quantità di caricamento 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 viene limitato da questo messaggio. Se sono specificati entrambi, |
TravelMode
Modalità di viaggio utilizzabili dai veicoli.
Dovrebbero essere un sottoinsieme delle modalità di viaggio dell'API Google Maps Platform Routes Preferred. Consulta la pagina: 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 a piedi. |
UnloadingPolicy
Norme sulle modalità di scarico di un veicolo. Si applica solo alle spedizioni con sia un ritiro che una consegna.
Altre spedizioni sono libere di avvenire ovunque sul percorso, indipendentemente da unloading_policy
.
Enum | |
---|---|
UNLOADING_POLICY_UNSPECIFIED |
Criterio di unload non specificato; le consegne devono avvenire solo 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 |
Waypoint
Incapsula una tappa. I waypoint contrassegnano le posizioni di arrivo e partenza delle VisitRequests e le posizioni di partenza e di arrivo dei Veicoli.
Campi | |
---|---|
side_of_road |
(Facoltativo) Indica che la posizione di questa tappa deve avere una preferenza che il veicolo si fermi in un determinato lato della strada. Quando imposti questo valore, il percorso attraversa la posizione in modo che il veicolo possa fermarsi sul lato della strada inclinato rispetto alla posizione rispetto al centro della strada. Questa opzione non funziona per "WALKING" modalità di viaggio. |
Campo unione location_type . Diversi modi per rappresentare un luogo. location_type può essere solo uno dei seguenti: |
|
location |
Un punto specificato utilizzando le coordinate geografiche, inclusa un'intestazione facoltativa. |
place_id |
L'ID luogo del PDI associato alla tappa. |