ShipmentModel

Un modèle d'envoi contient un ensemble d'envois qui doivent être effectués par un ensemble de véhicules, tout en minimisant le coût global, qui est la somme des éléments suivants :

  • le coût de l'itinéraire des véhicules (somme du coût par durée totale, du coût par temps de trajet et du coût fixe pour tous les véhicules).
  • les pénalités pour les livraisons non effectuées.
  • le coût de la durée globale des expéditions
Représentation JSON 
{
  "shipments": [
    {
      object (Shipment)
    }
  ],
  "vehicles": [
    {
      object (Vehicle)
    }
  ],
  "objectives": [
    {
      object (Objective)
    }
  ],
  "globalStartTime": string,
  "globalEndTime": string,
  "globalDurationCostPerHour": number,
  "durationDistanceMatrices": [
    {
      object (DurationDistanceMatrix)
    }
  ],
  "durationDistanceMatrixSrcTags": [
    string
  ],
  "durationDistanceMatrixDstTags": [
    string
  ],
  "transitionAttributes": [
    {
      object (TransitionAttributes)
    }
  ],
  "shipmentTypeIncompatibilities": [
    {
      object (ShipmentTypeIncompatibility)
    }
  ],
  "shipmentTypeRequirements": [
    {
      object (ShipmentTypeRequirement)
    }
  ],
  "precedenceRules": [
    {
      object (PrecedenceRule)
    }
  ],
  "maxActiveVehicles": integer
}
Champs
shipments[]

object (Shipment)

Ensemble d'envois à effectuer dans le modèle.
vehicles[]

object (Vehicle)

Ensemble de véhicules pouvant être utilisés pour effectuer des visites.
objectives[]

object (Objective)

Ensemble d'objectifs pour ce modèle, que nous transformerons en coûts. Si le champ n'est pas vide, le modèle d'entrée doit être sans coût. Pour obtenir la requête modifiée, veuillez utiliser solvingMode = TRANSFORM_AND_RETURN_REQUEST. Notez que la demande ne sera pas résolue dans ce cas. Consultez la documentation correspondante.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.
globalStartTime

string (Timestamp format)

Heures de début et de fin globales du modèle : aucune heure en dehors de cette plage ne peut être considérée comme valide.

La période du modèle doit être inférieure à un an, c'est-à-dire que l'intervalle entre globalEndTime et globalStartTime doit être inférieur à 31 536 000 secondes.

Lorsque vous utilisez des champs cost_per_*hour, vous pouvez définir un intervalle plus court pour cette période afin d'améliorer les performances (par exemple, si vous modélisez un seul jour, vous devez définir les limites de temps globales sur ce jour). Si ce champ n'est pas défini, la valeur par défaut est le 1er janvier 1970 à 00:00:00 UTC (c'est-à-dire seconds : 0, nanos : 0).

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
globalEndTime

string (Timestamp format)

Si ce champ n'est pas défini, la valeur par défaut est le 1er janvier 1971 à 00:00:00 UTC (soit 31536000 secondes, 0 nanoseconde).

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
globalDurationCostPerHour

number

La "durée globale" du plan global correspond à la différence entre l'heure de début effective la plus précoce et l'heure de fin effective la plus tardive de tous les véhicules. Les utilisateurs peuvent attribuer un coût par heure à cette quantité pour essayer d'optimiser l'exécution des jobs le plus tôt possible, par exemple. Ce coût doit être exprimé dans la même unité que Shipment.penalty_cost.
durationDistanceMatrices[]

object (DurationDistanceMatrix)

Spécifie les matrices de durée et de distance utilisées dans le modèle. Si ce champ est vide, Google Maps ou les distances géodésiques seront utilisées à la place, en fonction de la valeur du champ useGeodesicDistances. Si ce champ n'est pas vide, useGeodesicDistances ne peut pas être défini sur "true", et ni durationDistanceMatrixSrcTags ni durationDistanceMatrixDstTags ne peuvent être vides.

Exemples d'utilisation :

  • Il existe deux emplacements : locA et locB.
  • Un véhicule commençant son itinéraire à locA et le terminant à locA.
  • 1 demande de visite de collecte à locB.
model {
  vehicles { startTags: "locA"  endTags: "locA" }
  shipments { pickups { tags: "locB" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixDstTags: "locA"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrices {
    rows {  # from: locA
      durations { seconds: 0 }   meters: 0    # to: locA
      durations { seconds: 100 } meters: 1000 # to: locB
    }
    rows {  # from: locB
      durations { seconds: 102 } meters: 990 # to: locA
      durations { seconds: 0 }   meters: 0   # to: locB
    }
  }
}
  • Il existe trois emplacements : locA, locB et locC.
  • Un véhicule commençant son itinéraire à locA et le terminant à locB, en utilisant la matrice "fast".
  • Un véhicule commençant son itinéraire à locB et le terminant à locB, en utilisant la matrice "slow".
  • Un véhicule commençant son itinéraire à locB et le terminant à locB, en utilisant la matrice "fast".
  • 1 demande de visite de collecte à locC.
model {
  vehicles { startTags: "locA" endTags: "locB" startTags: "fast" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "slow" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "fast" }
  shipments { pickups { tags: "locC" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixSrcTags: "locC"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrixDstTags: "locC"
  durationDistanceMatrices {
    vehicleStartTag: "fast"
    rows {  # from: locA
      durations { seconds: 1000 } meters: 2000 # to: locB
      durations { seconds: 600 }  meters: 1000 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }   meters: 0    # to: locB
      durations { seconds: 700 } meters: 1200 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 702 } meters: 1190 # to: locB
      durations { seconds: 0 }   meters: 0    # to: locC
    }
  }
  durationDistanceMatrices {
    vehicleStartTag: "slow"
    rows {  # from: locA
      durations { seconds: 1800 } meters: 2001 # to: locB
      durations { seconds: 900 }  meters: 1002 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }    meters: 0    # to: locB
      durations { seconds: 1000 } meters: 1202 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 1001 } meters: 1195 # to: locB
      durations { seconds: 0 }    meters: 0    # to: locC
    }
  }
}
durationDistanceMatrixSrcTags[]

string

Tags définissant les sources des matrices de durée et de distance ; durationDistanceMatrices(i).rows(j) définit les durées et les distances entre les visites avec le tag durationDistanceMatrixSrcTags(j) et les autres visites de la matrice i.

Les tags correspondent à VisitRequest.tags ou Vehicle.start_tags. Un VisitRequest ou un Vehicle donné doit correspondre exactement à un tag de ce champ. Notez que les tags source, de destination et de matrice d'un Vehicle peuvent être identiques. De même, les tags source et de destination d'un VisitRequest peuvent être identiques. Tous les tags doivent être différents et ne peuvent pas être des chaînes vides. Si ce champ n'est pas vide, durationDistanceMatrices ne doit pas être vide.
durationDistanceMatrixDstTags[]

string

Tags définissant les destinations des matrices de durée et de distance ; durationDistanceMatrices(i).rows(j).durations(k) (resp. durationDistanceMatrices(i).rows(j).meters(k)) définit la durée (resp. la distance) du trajet entre les visites avec le tag durationDistanceMatrixSrcTags(j) et les visites avec le tag durationDistanceMatrixDstTags(k) dans la matrice i.

Les tags correspondent à VisitRequest.tags ou Vehicle.start_tags. Un VisitRequest ou un Vehicle donné doit correspondre exactement à un tag de ce champ. Notez que les tags source, de destination et de matrice d'un Vehicle peuvent être identiques. De même, les tags source et de destination d'un VisitRequest peuvent être identiques. Tous les tags doivent être différents et ne peuvent pas être des chaînes vides. Si ce champ n'est pas vide, durationDistanceMatrices ne doit pas être vide.
transitionAttributes[]

object (TransitionAttributes)

Attributs de transition ajoutés au modèle.
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

Ensembles de shipment_types incompatibles (voir ShipmentTypeIncompatibility).
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

Ensembles d'exigences shipmentType (voir ShipmentTypeRequirement).
precedenceRules[]

object (PrecedenceRule)

Ensemble de règles de priorité qui doivent être appliquées dans le modèle.

IMPORTANT : L'utilisation de règles de priorité limite la taille du problème pouvant être optimisé. Les requêtes utilisant des règles de priorité qui incluent de nombreux envois peuvent être refusées.
maxActiveVehicles

integer

Limite le nombre maximal de véhicules actifs. Un véhicule est actif si son itinéraire effectue au moins un envoi. Cela peut être utilisé pour limiter le nombre d'itinéraires lorsque le nombre de conducteurs est inférieur au nombre de véhicules et que la flotte de véhicules est hétérogène. L'optimisation sélectionnera ensuite le meilleur sous-ensemble de véhicules à utiliser. Doit être strictement positif.

Livraison

L'expédition d'un seul article, de l'un de ses points de retrait à l'un de ses points de livraison. Pour que l'envoi soit considéré comme effectué, un véhicule unique doit se rendre à l'un de ses lieux de retrait (et réduire ses capacités de réserve en conséquence), puis à l'un de ses lieux de livraison (et donc augmenter ses capacités de réserve en conséquence).

Représentation JSON 
{
  "displayName": string,
  "pickups": [
    {
      object (VisitRequest)
    }
  ],
  "deliveries": [
    {
      object (VisitRequest)
    }
  ],
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "allowedVehicleIndices": [
    integer
  ],
  "costsPerVehicle": [
    number
  ],
  "costsPerVehicleIndices": [
    integer
  ],
  "pickupToDeliveryAbsoluteDetourLimit": string,
  "pickupToDeliveryTimeLimit": string,
  "shipmentType": string,
  "label": string,
  "ignore": boolean,
  "penaltyCost": number,
  "pickupToDeliveryRelativeDetourLimit": number
}
Champs
displayName

string

Nom à afficher de l'envoi défini par l'utilisateur. Il peut comporter jusqu'à 63 caractères et utiliser des caractères UTF-8.
pickups[]

object (VisitRequest)

Ensemble d'alternatives de retrait associées à l'envoi. Si aucune valeur n'est spécifiée, le véhicule n'a besoin de se rendre qu'à un emplacement correspondant aux livraisons.
deliveries[]

object (VisitRequest)

Ensemble d'alternatives de livraison associées à l'envoi. Si ce paramètre n'est pas spécifié, le véhicule n'a qu'à se rendre à un emplacement correspondant aux prises en charge.
loadDemands

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

Exigences de chargement de l'envoi (par exemple, poids, volume, nombre de palettes, etc.) Les clés de la carte doivent être des identifiants décrivant le type de charge correspondante, idéalement en incluant également les unités. Par exemple : "weight_kg", "volume_gallons", "pallet_count", etc. Si une clé donnée n'apparaît pas dans la carte, la charge correspondante est considérée comme nulle.
allowedVehicleIndices[]

integer

Ensemble de véhicules pouvant effectuer cette livraison. Si ce champ est vide, tous les véhicules peuvent l'effectuer. Les véhicules sont indiqués par leur index dans la liste vehicles de ShipmentModel.
costsPerVehicle[]

number

Spécifie le coût encouru lorsque cet envoi est livré par chaque véhicule. Si elle est spécifiée, elle doit comporter :

  • le même nombre d'éléments que costsPerVehicleIndices. costsPerVehicle[i] correspond au véhicule costsPerVehicleIndices[i] du modèle.
  • le même nombre d'éléments que de véhicules dans le modèle. Le i-ème élément correspond au véhicule n° i du modèle.

Ces coûts doivent être exprimés dans la même unité que penaltyCost et ne doivent pas être négatifs. Laissez ce champ vide s'il n'y a pas de frais de ce type.
costsPerVehicleIndices[]

integer

Indices des véhicules auxquels costsPerVehicle s'applique. S'il n'est pas vide, il doit comporter le même nombre d'éléments que costsPerVehicle. Un index de véhicule ne peut pas être spécifié plus d'une fois. Si un véhicule est exclu de costsPerVehicleIndices, son coût est de zéro.
pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

Spécifie le temps de détour absolu maximal par rapport au trajet le plus court entre le point de retrait et le point de livraison. Si elle est spécifiée, elle doit être non négative, et l'envoi doit contenir au moins un enlèvement et une livraison.

Par exemple, soit t le temps le plus court pour aller de l'alternative de retrait sélectionnée directement à l'alternative de livraison sélectionnée. Ensuite, la définition de pickupToDeliveryAbsoluteDetourLimit applique :

startTime(delivery) - startTime(pickup) <=
t + pickupToDeliveryAbsoluteDetourLimit

Si des limites relatives et absolues sont spécifiées pour un même envoi, la limite la plus contraignante est utilisée pour chaque paire de retrait/livraison possible. Depuis octobre 2017, les détours ne sont acceptés que lorsque les durées de trajet ne dépendent pas des véhicules.
pickupToDeliveryTimeLimit

string (Duration format)

Spécifie la durée maximale entre le début de l'enlèvement et le début de la livraison d'un envoi. Si elle est spécifiée, elle doit être non négative, et l'envoi doit contenir au moins un enlèvement et une livraison. Cela ne dépend pas des alternatives sélectionnées pour l'enlèvement et la livraison, ni de la vitesse du véhicule. Vous pouvez spécifier cette option en même temps que les contraintes de détour maximal : la solution respectera les deux spécifications.
shipmentType

string

Chaîne non vide spécifiant un "type" pour cet envoi. Cette fonctionnalité permet de définir des incompatibilités ou des exigences entre les shipment_types (voir shipmentTypeIncompatibilities et shipmentTypeRequirements dans ShipmentModel).

Diffère de visitTypes, qui est spécifié pour une seule visite : tous les enlèvements/livraisons appartenant au même envoi partagent le même shipmentType.
label

string

Spécifie un libellé pour cet envoi. Cette étiquette est indiquée dans la réponse dans le champ shipmentLabel de l'élément ShipmentRoute.Visit correspondant.
ignore

boolean

Si la valeur est "true", ignorez cet envoi, mais n'appliquez pas de penaltyCost.

Ignorer un envoi entraîne une erreur de validation lorsqu'il y a des shipmentTypeRequirements dans le modèle.

Il est possible d'ignorer un envoi effectué dans injectedFirstSolutionRoutes ou injectedSolutionConstraint. L'outil de résolution supprime les visites de retrait/livraison associées de l'itinéraire d'exécution. precedenceRules qui font référence à des envois ignorés seront également ignorés.
penaltyCost

number

Si l'envoi n'est pas effectué, cette pénalité est ajoutée au coût global des itinéraires. Un envoi est considéré comme terminé si l'une de ses alternatives de retrait et de livraison est visitée. Le coût peut être exprimé dans la même unité que celle utilisée pour tous les autres champs liés aux coûts dans le modèle, et il doit être positif.

IMPORTANT : Si cette pénalité n'est pas spécifiée, elle est considérée comme infinie, c'est-à-dire que l'envoi doit être effectué.
pickupToDeliveryRelativeDetourLimit

number

Spécifie le temps de détour relatif maximal par rapport au trajet le plus court entre le point de retrait et le point de livraison. Si elle est spécifiée, elle doit être non négative, et l'envoi doit contenir au moins un enlèvement et une livraison.

Par exemple, soit t le temps le plus court pour aller de l'alternative de retrait sélectionnée directement à l'alternative de livraison sélectionnée. Ensuite, la définition de pickupToDeliveryRelativeDetourLimit applique :

startTime(delivery) - startTime(pickup) <=
std::ceil(t * (1.0 + pickupToDeliveryRelativeDetourLimit))

Si des limites relatives et absolues sont spécifiées pour un même envoi, la limite la plus contraignante est utilisée pour chaque paire de retrait/livraison possible. Depuis octobre 2017, les détours ne sont acceptés que lorsque les durées de trajet ne dépendent pas des véhicules.

VisitRequest

Demande de visite pouvant être effectuée par un véhicule : elle comporte une géolocalisation (ou deux, voir ci-dessous), des heures d'ouverture et de fermeture représentées par des périodes, et une durée de service (temps passé par le véhicule une fois arrivé pour récupérer ou déposer des marchandises).

Représentation JSON 
{
  "arrivalLocation": {
    object (LatLng)
  },
  "arrivalWaypoint": {
    object (Waypoint)
  },
  "departureLocation": {
    object (LatLng)
  },
  "departureWaypoint": {
    object (Waypoint)
  },
  "tags": [
    string
  ],
  "timeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "duration": string,
  "cost": number,
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "visitTypes": [
    string
  ],
  "label": string,
  "avoidUTurns": boolean
}
Champs
arrivalLocation

object (LatLng)

Emplacement géographique où le véhicule arrive lorsqu'il effectue cette VisitRequest. Si le modèle d'envoi comporte des matrices de distance de durée, arrivalLocation ne doit pas être spécifié.
arrivalWaypoint

object (Waypoint)

Point de cheminement où le véhicule arrive lorsqu'il effectue cette VisitRequest. Si le modèle d'envoi comporte des matrices de distance de durée, arrivalWaypoint ne doit pas être spécifié.
departureLocation

object (LatLng)

Emplacement géographique d'où part le véhicule après avoir terminé cette VisitRequest. Peut être omis s'il est identique à arrivalLocation. Si le modèle d'envoi comporte des matrices de distance de durée, departureLocation ne doit pas être spécifié.
departureWaypoint

object (Waypoint)

Point de cheminement d'où le véhicule part après avoir terminé cette VisitRequest. Peut être omis s'il est identique à arrivalWaypoint. Si le modèle d'envoi comporte des matrices de distance de durée, departureWaypoint ne doit pas être spécifié.
tags[]

string

Spécifie les tags associés à la demande de visite. Les chaînes vides ou en double ne sont pas autorisées.
timeWindows[]

object (TimeWindow)

Plages horaires qui limitent l'heure d'arrivée à une visite. Notez qu'un véhicule peut partir en dehors de la période d'arrivée, c'est-à-dire que l'heure d'arrivée et la durée n'ont pas besoin de se situer dans une période. Cela peut entraîner un temps d'attente si le véhicule arrive avant TimeWindow.start_time.

L'absence de TimeWindow signifie que le véhicule peut effectuer cette visite à tout moment.

Les intervalles de temps doivent être disjoints, c'est-à-dire qu'aucun intervalle de temps ne doit chevaucher un autre ou être adjacent à un autre, et ils doivent être dans l'ordre croissant.

costPerHourAfterSoftEndTime et softEndTime ne peuvent être définis que s'il n'y a qu'un seul intervalle de temps.
duration

string (Duration format)

Durée de la visite, c'est-à-dire le temps passé par le véhicule entre l'arrivée et le départ (à ajouter au temps d'attente possible ; voir timeWindows).
cost

number

Coût de la prise en charge de cette demande de visite sur un itinéraire de véhicule. Vous pouvez l'utiliser pour payer des frais différents pour chaque retrait ou livraison d'un envoi. Ce coût doit être exprimé dans la même unité que Shipment.penalty_cost et ne doit pas être négatif.
loadDemands

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

Demandes de chargement de cette demande de visite. Ce champ est identique au champ Shipment.load_demands, mais il ne s'applique qu'à ce VisitRequest au lieu de l'ensemble de l'Shipment. Les demandes listées ici sont ajoutées à celles listées dans Shipment.load_demands.
visitTypes[]

string

Spécifie les types de visite. Cela peut être utilisé pour allouer le temps supplémentaire nécessaire à un véhicule pour effectuer cette visite (voir Vehicle.extra_visit_duration_for_visit_type).

Un type ne peut apparaître qu'une seule fois.
label

string

Spécifie un libellé pour ce VisitRequest. Cette étiquette est signalée dans la réponse en tant que visitLabel dans le ShipmentRoute.Visit correspondant.
avoidUTurns

boolean

Indique si les demi-tours doivent être évités sur les itinéraires en voiture à cet emplacement. L'évitement des demi-tours est effectué dans la mesure du possible, mais un évitement complet n'est pas garanti. Il s'agit d'une fonctionnalité expérimentale dont le comportement est susceptible de changer.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request.

LatLng

Objet représentant une paire latitude/longitude. Cette valeur est exprimée par une paire de doubles représentant les degrés de latitude et de longitude. Sauf indication contraire, cet objet doit être conforme à la norme WGS84. Les valeurs doivent se situer dans les limites normalisées.

Représentation JSON 
{
  "latitude": number,
  "longitude": number
}
Champs
latitude

number

Latitude en degrés. Elle doit être comprise dans la plage [-90.0, +90.0].
longitude

number

Longitude en degrés. Elle doit être comprise dans la plage [-180.0, +180.0].

Repère

Encapsule un point de cheminement. Les points de cheminement marquent les lieux d'arrivée et de départ des VisitRequests, ainsi que les lieux de départ et d'arrivée des véhicules.

Représentation JSON 
{
  "sideOfRoad": boolean,
  "vehicleStopover": boolean,

  // The following is a list of mutually exclusive fields. At most one of the
  // fields will be set in a response:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of mutually exclusive fields.
}
Champs
sideOfRoad

boolean

Facultatif. Indique que l'emplacement de ce point de cheminement est destiné à indiquer une préférence pour que le véhicule s'arrête d'un côté particulier de la route. Lorsque vous définissez cette valeur, l'itinéraire passe par l'emplacement de sorte que le véhicule puisse s'arrêter du côté de la route vers lequel l'emplacement est orienté par rapport au centre de la route. Cette option ne fonctionne pas pour le mode de transport "WALKING".
vehicleStopover

boolean

Indique que le point de cheminement est destiné à l'arrêt des véhicules, dans le but de prendre ou de déposer des passagers. Cette option ne fonctionne que pour le mode de transport "DRIVING" et lorsque "locationType" est défini sur "location".

Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
Différentes façons de représenter un lieu. Voici une liste de champs mutuellement exclusifs. Au maximum, un des champs sera défini dans une réponse :
location

object (Location)

Point spécifié à l'aide de coordonnées géographiques, y compris un cap facultatif.
placeId

string

ID de lieu du point d'intérêt associé au point de cheminement.

Lorsque vous utilisez un ID de lieu pour spécifier le lieu d'arrivée ou de départ d'une requête VisitRequest, utilisez un ID de lieu suffisamment spécifique pour déterminer un emplacement LatLng pour la navigation vers le lieu. Par exemple, un ID de lieu représentant un bâtiment est approprié, mais un ID de lieu représentant une route est déconseillé.
Fin des champs mutuellement exclusifs.

Emplacement

Encapsule un emplacement (un point géographique et un cap facultatif).

Représentation JSON 
{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}
Champs
latLng

object (LatLng)

Coordonnées géographiques du point de cheminement.
heading

integer

Orientation de la boussole associée à la direction du flux de trafic. Cette valeur permet de spécifier le côté de la route à utiliser pour la prise en charge et la dépose. Les valeurs de cap peuvent être comprises entre 0 et 360, où 0 correspond au nord, 90 à l'est, etc.

TimeWindow

Les périodes limitent l'heure d'un événement, comme l'heure d'arrivée d'une visite, ou l'heure de début et de fin d'un véhicule.

Les limites strictes de la période, startTime et endTime, appliquent l'heure de début et de fin de l'événement, de sorte que startTime <= event_time <= endTime. La limite inférieure de la période flexible, softStartTime, exprime une préférence pour que l'événement se produise à softStartTime ou après, en entraînant un coût proportionnel au temps écoulé avant softStartTime. La limite supérieure de la période flexible, softEndTime, exprime une préférence pour que l'événement se produise au plus tard à softEndTime, en entraînant un coût proportionnel au temps écoulé après softEndTime. startTime, endTime, softStartTime et softEndTime doivent respecter les limites de temps globales (voir ShipmentModel.global_start_time et ShipmentModel.global_end_time) et les conditions suivantes :

  0 <= `startTime` <= `endTime` and
  0 <= `startTime` <= `softStartTime` and
  0 <= `softEndTime` <= `endTime`.
Représentation JSON 
{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}
Champs
startTime

string (Timestamp format)

Heure de début de l'intervalle de temps strict. Si aucune valeur n'est spécifiée, elle est définie sur ShipmentModel.global_start_time.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
endTime

string (Timestamp format)

Heure de fin de la période stricte. Si aucune valeur n'est spécifiée, elle est définie sur ShipmentModel.global_end_time.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
softStartTime

string (Timestamp format)

Heure de début de la période.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
softEndTime

string (Timestamp format)

Heure de fin flexible de la période.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
costPerHourBeforeSoftStartTime

number

Coût par heure ajouté aux autres coûts du modèle si l'événement se produit avant softStartTime, calculé comme suit :

   max(0, softStartTime - t.seconds)
                          * costPerHourBeforeSoftStartTime / 3600,
t being the time of the event.

Ce coût doit être positif, et le champ ne peut être défini que si softStartTime a été défini.
costPerHourAfterSoftEndTime

number

Coût par heure ajouté aux autres coûts du modèle si l'événement se produit après softEndTime, calculé comme suit :

   max(0, t.seconds - softEndTime.seconds)
                    * costPerHourAfterSoftEndTime / 3600,
t being the time of the event.

Ce coût doit être positif, et le champ ne peut être défini que si softEndTime a été défini.

Véhicule

Modélise un véhicule dans un problème d'expédition. La résolution d'un problème d'expédition créera un itinéraire commençant à startLocation et se terminant à endLocation pour ce véhicule. Un itinéraire est une séquence de visites (voir ShipmentRoute).

Représentation JSON 
{
  "displayName": string,
  "travelMode": enum (TravelMode),
  "routeModifiers": {
    object (RouteModifiers)
  },
  "startLocation": {
    object (LatLng)
  },
  "startWaypoint": {
    object (Waypoint)
  },
  "endLocation": {
    object (LatLng)
  },
  "endWaypoint": {
    object (Waypoint)
  },
  "startTags": [
    string
  ],
  "endTags": [
    string
  ],
  "startTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "endTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "unloadingPolicy": enum (UnloadingPolicy),
  "loadLimits": {
    string: {
      object (LoadLimit)
    },
    ...
  },
  "costPerHour": number,
  "costPerTraveledHour": number,
  "costPerKilometer": number,
  "fixedCost": number,
  "usedIfRouteIsEmpty": boolean,
  "routeDurationLimit": {
    object (DurationLimit)
  },
  "travelDurationLimit": {
    object (DurationLimit)
  },
  "routeDistanceLimit": {
    object (DistanceLimit)
  },
  "extraVisitDurationForVisitType": {
    string: string,
    ...
  },
  "breakRule": {
    object (BreakRule)
  },
  "label": string,
  "ignore": boolean,
  "travelDurationMultiple": number
}
Champs
displayName

string

Nom à afficher du véhicule défini par l'utilisateur. Il peut comporter jusqu'à 63 caractères et utiliser des caractères UTF-8.
travelMode

enum (TravelMode)

Mode de transport qui affecte les routes utilisables par le véhicule et sa vitesse. Consultez également travelDurationMultiple.
routeModifiers

object (RouteModifiers)

Ensemble de conditions à remplir qui affectent la façon dont les itinéraires sont calculés pour le véhicule donné.
startLocation

object (LatLng)

Emplacement géographique où le véhicule démarre avant de récupérer des expéditions. Si ce champ n'est pas spécifié, le véhicule démarre à son premier point de retrait. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, startLocation ne doit pas être spécifié.
startWaypoint

object (Waypoint)

Point de cheminement représentant un emplacement géographique où le véhicule démarre avant de récupérer des envois. Si ni startWaypoint ni startLocation n'est spécifié, le véhicule démarre à sa première prise en charge. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, startWaypoint ne doit pas être spécifié.
endLocation

object (LatLng)

Emplacement géographique où le véhicule termine son trajet après avoir effectué sa dernière VisitRequest. Si ce paramètre n'est pas spécifié, le ShipmentRoute du véhicule se termine immédiatement lorsqu'il effectue sa dernière VisitRequest. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, endLocation ne doit pas être spécifié.
endWaypoint

object (Waypoint)

Point de cheminement représentant un emplacement géographique où le véhicule s'arrête après avoir terminé sa dernière VisitRequest. Si ni endWaypoint ni endLocation n'est spécifié, le ShipmentRoute du véhicule se termine immédiatement lorsqu'il termine sa dernière VisitRequest. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, endWaypoint ne doit pas être spécifié.
startTags[]

string

Spécifie les tags associés au début de l'itinéraire du véhicule.

Les chaînes vides ou en double ne sont pas autorisées.
endTags[]

string

Spécifie les tags associés à la fin de l'itinéraire du véhicule.

Les chaînes vides ou en double ne sont pas autorisées.
startTimeWindows[]

object (TimeWindow)

Intervalles de temps pendant lesquels le véhicule peut quitter son point de départ. Ils doivent respecter les limites de temps globales (voir les champs ShipmentModel.global_*). Si aucune valeur n'est spécifiée, il n'y a pas de limite autre que ces limites de temps globales.

Les périodes appartenant au même champ répété doivent être disjointes, c'est-à-dire qu'aucune période ne peut chevaucher une autre ou être adjacente à une autre, et elles doivent être classées par ordre chronologique.

costPerHourAfterSoftEndTime et softEndTime ne peuvent être définis que s'il n'y a qu'un seul intervalle de temps.
endTimeWindows[]

object (TimeWindow)

Créneaux horaires pendant lesquels le véhicule peut arriver à son emplacement final. Ils doivent respecter les limites de temps globales (voir les champs ShipmentModel.global_*). Si aucune valeur n'est spécifiée, il n'y a pas de limite autre que ces limites de temps globales.

Les périodes appartenant au même champ répété doivent être disjointes, c'est-à-dire qu'aucune période ne peut chevaucher une autre ou être adjacente à une autre, et elles doivent être classées par ordre chronologique.

costPerHourAfterSoftEndTime et softEndTime ne peuvent être définis que s'il n'y a qu'un seul intervalle de temps.
unloadingPolicy

enum (UnloadingPolicy)

Règle de déchargement appliquée au véhicule.
loadLimits

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

Capacités du véhicule (poids, volume, nombre de palettes, par exemple). Les clés de la carte sont les identifiants du type de charge, conformément aux clés du champ Shipment.load_demands. Si une clé donnée est absente de ce mappage, la capacité correspondante est considérée comme illimitée.
costPerHour

number

Coûts du véhicule : tous les coûts s'additionnent et doivent être exprimés dans la même unité que Shipment.penalty_cost.

Coût par heure de l'itinéraire du véhicule. Ce coût est appliqué à la durée totale de l'itinéraire, et inclut le temps de trajet, le temps d'attente et le temps de visite. L'utilisation de costPerHour au lieu de costPerTraveledHour peut entraîner une latence supplémentaire.
costPerTraveledHour

number

Coût par heure de trajet de l'itinéraire du véhicule. Ce coût ne s'applique qu'au temps de trajet de l'itinéraire (c'est-à-dire celui indiqué dans ShipmentRoute.transitions) et exclut le temps d'attente et le temps de visite.
costPerKilometer

number

Coût par kilomètre de l'itinéraire du véhicule. Ce coût est appliqué à la distance indiquée dans le ShipmentRoute.transitions et ne s'applique pas à la distance parcourue implicitement entre le arrivalLocation et le departureLocation d'un même VisitRequest.
fixedCost

number

Coût fixe appliqué si ce véhicule est utilisé pour gérer un envoi.
usedIfRouteIsEmpty

boolean

Ce champ ne s'applique aux véhicules que lorsque leur itinéraire ne dessert aucun envoi. Indique si le véhicule doit être considéré comme d'occasion ou non dans ce cas.

Si la valeur est "true", le véhicule se déplace de son point de départ à son point d'arrivée même s'il ne livre aucun envoi, et les coûts de temps et de distance résultant de son trajet de départ à l'arrivée sont pris en compte.

Sinon, il ne se déplace pas de son point de départ à son point d'arrivée, et aucun breakRule ni retard (de TransitionAttributes) n'est programmé pour ce véhicule. Dans ce cas, le ShipmentRoute du véhicule ne contient aucune information, à l'exception de l'index et du libellé du véhicule.
routeDurationLimit

object (DurationLimit)

Limite appliquée à la durée totale de l'itinéraire du véhicule. Dans un OptimizeToursResponse donné, la durée de l'itinéraire d'un véhicule correspond à la différence entre son vehicleEndTime et son vehicleStartTime.
travelDurationLimit

object (DurationLimit)

Limite appliquée à la durée du trajet de l'itinéraire du véhicule. Dans un OptimizeToursResponse donné, la durée du trajet est la somme de tous ses transitions.travel_duration.
routeDistanceLimit

object (DistanceLimit)

Limite appliquée à la distance totale de l'itinéraire du véhicule. Dans un OptimizeToursResponse donné, la distance de l'itinéraire est la somme de toutes ses transitions.travel_distance_meters.
extraVisitDurationForVisitType

map (key: string, value: string (Duration format))

Spécifie un mappage des chaînes visitTypes vers des durées. La durée correspond au temps supplémentaire par rapport à VisitRequest.duration à prendre lors des visites avec la visitTypes spécifiée. Cette durée de visite supplémentaire entraîne des coûts si costPerHour est spécifié. Les clés (par exemple, visitTypes) ne peuvent pas être des chaînes vides.

Si une demande de visite comporte plusieurs types, une durée sera ajoutée pour chaque type dans la carte.
breakRule

object (BreakRule)

Décrit le planning des pauses à appliquer à ce véhicule. Si ce champ est vide, aucune pause ne sera programmée pour ce véhicule.
label

string

Spécifie un libellé pour ce véhicule. Cette étiquette est renvoyée dans la réponse en tant que vehicleLabel de l'élément ShipmentRoute correspondant.
ignore

boolean

Si la valeur est "true", usedIfRouteIsEmpty doit être "false" et ce véhicule ne sera pas utilisé.

Si un envoi est effectué par un véhicule ignoré dans injectedFirstSolutionRoutes, il est ignoré dans la première solution, mais peut être effectué dans la réponse.

Si un envoi est effectué par un véhicule ignoré dans injectedSolutionConstraint et que tout retrait/livraison associé doit rester sur le véhicule (c'est-à-dire qu'il n'est pas assoupli au niveau RELAX_ALL_AFTER_THRESHOLD), il est ignoré dans la réponse. Si un envoi comporte un champ allowedVehicleIndices non vide et que tous les véhicules autorisés sont ignorés, il est ignoré dans la réponse.
travelDurationMultiple

number

Spécifie un facteur multiplicatif qui peut être utilisé pour augmenter ou diminuer les temps de trajet de ce véhicule. Par exemple, si vous définissez cette valeur sur 2, cela signifie que ce véhicule est plus lent et que ses temps de trajet sont deux fois plus longs que ceux des véhicules standards. Ce multiple n'affecte pas la durée des visites. Cela a une incidence sur le coût si costPerHour ou costPerTraveledHour sont spécifiés. Cette valeur doit être comprise entre 0,001 et 1 000,0. Si ce champ n'est pas défini, le véhicule est standard et ce multiplicateur est considéré comme égal à 1, 0.

AVERTISSEMENT : Les temps de trajet seront arrondis à la seconde la plus proche après l'application de ce multiple, mais avant d'effectuer des opérations numériques. Par conséquent, un petit multiple peut entraîner une perte de précision.

Voir également extraVisitDurationForVisitType ci-dessous.

TravelMode

Modes de transport pouvant être utilisés par les véhicules.

Il doit s'agir d'un sous-ensemble des modes de transport de l'API Routes de Google Maps Platform. Consultez https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode.

Remarque : Les itinéraires WALKING sont en version bêta et peuvent parfois ne pas comporter de trottoirs ou de voies piétonnes clairs. Vous devez afficher cet avertissement pour tous les itinéraires à pied que vous affichez dans votre application.

Enums
TRAVEL_MODE_UNSPECIFIED Mode de transport non spécifié, équivalent à DRIVING.
DRIVING Mode de transport correspondant aux itinéraires en voiture (voiture, etc.).
WALKING Mode de transport correspondant à un itinéraire à pied.
TWO_WHEELER Véhicule motorisé à deux roues. Par exemple, "moto". Notez que ce mode diffère du mode de transport BICYCLING, qui couvre les modes de transport à propulsion humaine. Ce mode de transport n'est disponible que dans les pays listés sur la page Pays et régions où les deux-roues sont acceptés.

RouteModifiers

Encapsule un ensemble de conditions facultatives à remplir lors du calcul des itinéraires des véhicules. Cette option est semblable à RouteModifiers dans l'API Routes Preferred de Google Maps Platform. Consultez https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers.

Représentation JSON 
{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}
Champs
avoidTolls

boolean

Indique s'il faut éviter les routes à péage dans la mesure du possible. La priorité sera donnée aux itinéraires ne comportant pas de routes à péage. S'applique uniquement aux modes de transport motorisés.
avoidHighways

boolean

Indique s'il faut éviter les autoroutes dans la mesure du possible. La priorité sera donnée aux itinéraires ne contenant pas d'autoroutes. S'applique uniquement aux modes de transport motorisés.
avoidFerries

boolean

Indique s'il faut éviter les ferries dans la mesure du possible. La priorité sera donnée aux itinéraires n'incluant pas de trajets en ferry. S'applique uniquement aux modes de transport motorisés.
avoidIndoor

boolean

Facultatif. Indique s'il faut éviter de naviguer en intérieur lorsque cela est possible. La priorité sera donnée aux itinéraires ne contenant pas de navigation en intérieur. S'applique uniquement au mode de transport WALKING.

UnloadingPolicy

Règle sur la façon dont un véhicule peut être déchargé. S'applique uniquement aux envois comportant à la fois un retrait et une livraison.

Les autres envois peuvent avoir lieu n'importe où sur l'itinéraire, indépendamment de unloadingPolicy.

Enums
UNLOADING_POLICY_UNSPECIFIED Règle de déchargement non spécifiée : les livraisons doivent simplement avoir lieu après les collectes correspondantes.
LAST_IN_FIRST_OUT Les livraisons doivent être effectuées dans l'ordre inverse des retraits
FIRST_IN_FIRST_OUT Les livraisons doivent être effectuées dans le même ordre que les prises en charge

LoadLimit

Définit une limite de charge s'appliquant à un véhicule, par exemple "ce camion ne peut transporter que 3 500 kg". Consultez les loadLimits.

Représentation JSON 
{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string,
  "costPerKilometer": {
    object (LoadCost)
  },
  "costPerTraveledHour": {
    object (LoadCost)
  }
}
Champs
softMaxLoad

string (int64 format)

Limite souple de la charge. Consultez les costPerUnitAboveSoftMax.
costPerUnitAboveSoftMax

number

Si la charge dépasse softMaxLoad sur l'itinéraire de ce véhicule, la pénalité de coût suivante s'applique (une seule fois par véhicule) : (charge - softMaxLoad) * costPerUnitAboveSoftMax. Tous les coûts s'additionnent et doivent être exprimés dans la même unité que Shipment.penalty_cost. Les limites souples ne peuvent être définies que sur les types qui s'appliquent uniquement aux retraits ou uniquement aux livraisons dans l'ensemble du modèle.
startLoadInterval

object (Interval)

Intervalle de charge acceptable du véhicule au début de l'itinéraire.
endLoadInterval

object (Interval)

Intervalle de charge acceptable du véhicule à la fin de l'itinéraire.
maxLoad

string (int64 format)

La quantité de charge maximale acceptable.
costPerKilometer

object (LoadCost)

Coût du déplacement d'une unité de charge sur un kilomètre pour ce véhicule. Cela peut être utilisé comme indicateur de la consommation de carburant : si la charge est un poids (en Newtons), alors charge*kilomètre a la dimension d'une énergie.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.
costPerTraveledHour

object (LoadCost)

Coût du transport d'une unité de charge pendant une heure pour ce véhicule.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

Intervalle

Intervalle des quantités de charge acceptables.

Représentation JSON 
{
  "min": string,
  "max": string
}
Champs
min

string (int64 format)

Une charge minimale acceptable. Doit être ≥ 0. Si les deux sont spécifiés, min doit être inférieur ou égal à max.
max

string (int64 format)

Une charge maximale acceptable. Doit être ≥ 0. Si ce paramètre n'est pas spécifié, la charge maximale n'est pas limitée par ce message. Si les deux sont spécifiés, min doit être inférieur ou égal à max.

LoadCost

Coût du déplacement d'une unité de charge pendant un Transition. Pour une charge donnée, le coût est la somme de deux parties :

  • min(load, loadThreshold) * costPerUnitBelowThreshold
  • max(0, load - loadThreshold) * costPerUnitAboveThreshold

Avec ce coût, les solutions préfèrent livrer les demandes élevées en premier, ou, de manière équivalente, récupérer les demandes élevées en dernier. Par exemple, si un véhicule est équipé

load_limit {
  key: "weight"
  value {
    costPerKilometer {
      loadThreshold: 15
      costPerUnitBelowThreshold: 2.0
      costPerUnitAboveThreshold: 10.0
    }
  }
}

et son itinéraire est start,pickup,pickup,delivery,delivery,end avec les transitions :

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 20 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

alors le coût encouru par ce LoadCost est (cost_below * load_below * kilometers + cost_above * load_above * kms)

  • transition 0: 0.0
  • transition 1 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transition 2 : 2,0 * 15 * 1,0 + 10,0 * (20 - 15) * 1,0 = 80,0
  • transition 3 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transition 4: 0.0

La valeur de LoadCost sur la route est donc de 120,0.

Toutefois, si l'itinéraire est start,pickup,delivery,pickup,delivery,end avec les transitions :

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

alors le coût de cette LoadCost est de

  • transition 0: 0.0
  • transition 1 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transition 2 : 0,0
  • transition 3 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
  • transition 4: 0.0

Ici, la valeur LoadCost sur l'itinéraire est de 40,0.

LoadCost rend les solutions avec des transitions lourdes plus coûteuses.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

Représentation JSON 
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
Champs
loadThreshold

string (int64 format)

Quantité de charge au-dessus de laquelle le coût de déplacement d'une unité de charge passe de costPerUnitBelowThreshold à costPerUnitAboveThreshold. Doit être supérieur ou égal à 0.
costPerUnitBelowThreshold

number

Coût du déplacement d'une unité de charge, pour chaque unité comprise entre 0 et le seuil. Doit être une valeur finie et supérieure ou égale à 0.
costPerUnitAboveThreshold

number

Coût du déplacement d'une unité de charge, pour chaque unité au-dessus du seuil. Dans le cas particulier où le seuil est égal à 0, il s'agit d'un coût fixe par unité. Doit être une valeur finie et supérieure ou égale à 0.

DurationLimit

Limite définissant une durée maximale de l'itinéraire d'un véhicule. Il peut s'agir d'une limite stricte ou d'une limite souple.

Lorsqu'un champ de limite souple est défini, le seuil maximal souple et le coût associé doivent être définis ensemble.

Représentation JSON 
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
Champs
maxDuration

string (Duration format)

Limite stricte limitant la durée à maxDuration au maximum.
softMaxDuration

string (Duration format)

Limite souple n'imposant pas de durée maximale, mais qui, lorsqu'elle n'est pas respectée, entraîne un coût pour l'itinéraire. Ce coût s'ajoute aux autres coûts définis dans le modèle, avec la même unité.

S'il est défini, softMaxDuration doit être non négatif. Si maxDuration est également défini, softMaxDuration doit être inférieur à maxDuration.
quadraticSoftMaxDuration

string (Duration format)

Limite souple n'imposant pas de durée maximale, mais qui, lorsqu'elle est dépassée, entraîne un coût quadratique pour l'itinéraire en fonction de la durée. Ce coût s'ajoute aux autres coûts définis dans le modèle, avec la même unité.

Si quadraticSoftMaxDuration est défini, les conditions suivantes doivent être remplies :

  • Il ne doit pas être négatif.
  • maxDuration doit être défini.
  • quadraticSoftMaxDuration doit être inférieur à maxDuration.
  • La différence ne doit pas dépasser un jour : maxDuration - quadraticSoftMaxDuration <= 86400 seconds
costPerHourAfterSoftMax

number

Coût horaire encouru si le seuil softMaxDuration est dépassé. Le coût supplémentaire est de 0 si la durée est inférieure au seuil. Sinon, le coût dépend de la durée comme suit :

  costPerHourAfterSoftMax * (duration - softMaxDuration)

Le coût ne doit pas être négatif.
costPerSquareHourAfterQuadraticSoftMax

number

Coût par heure au carré encouru si le seuil quadraticSoftMaxDuration est dépassé.

Le coût supplémentaire est de 0 si la durée est inférieure au seuil. Sinon, le coût dépend de la durée comme suit :

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

Le coût ne doit pas être négatif.

DistanceLimit

Limite définissant une distance maximale pouvant être parcourue. Il peut s'agir d'une limite stricte ou d'une limite souple.

Si une limite souple est définie, softMaxMeters et costPerKilometerAboveSoftMax doivent être définis et ne pas être négatifs.

Représentation JSON 
{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}
Champs
maxMeters

string (int64 format)

Limite stricte limitant la distance à maxMeters au maximum. La limite ne doit pas être négative.
softMaxMeters

string (int64 format)

Une limite souple n'impose pas de limite de distance maximale, mais son non-respect entraîne un coût qui s'ajoute aux autres coûts définis dans le modèle, avec la même unité.

Si elle est définie, la valeur softMaxMeters doit être inférieure à maxMeters et ne doit pas être négative.
costPerKilometerBelowSoftMax

number

Coût par kilomètre encouru, jusqu'à softMaxMeters, avec la formule :

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

Ce coût n'est pas accepté dans routeDistanceLimit.
costPerKilometerAboveSoftMax

number

Coût par kilomètre encouru si la distance est supérieure à la limite de softMaxMeters. Le coût supplémentaire est de 0 si la distance est inférieure à la limite. Sinon, la formule utilisée pour calculer le coût est la suivante :

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

Le coût ne doit pas être négatif.

BreakRule

Règles permettant de générer des pauses pour un véhicule (par exemple, des pauses déjeuner). Une pause est une période continue pendant laquelle le véhicule reste inactif à sa position actuelle et ne peut effectuer aucune visite. Une rupture peut se produire :

  • pendant le trajet entre deux visites (ce qui inclut le temps juste avant ou juste après une visite, mais pas au milieu d'une visite), auquel cas il prolonge le temps de trajet correspondant entre les visites ;
  • ou avant le départ du véhicule (le véhicule ne peut pas démarrer au milieu d'une pause), auquel cas elle n'affecte pas l'heure de départ du véhicule.
  • ou après la fin du véhicule (idem, avec l'heure de fin du véhicule).
Représentation JSON 
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
Champs
breakRequests[]

object (BreakRequest)

Séquence de pauses. Consultez le message BreakRequest.
frequencyConstraints[]

object (FrequencyConstraint)

Plusieurs FrequencyConstraint peuvent s'appliquer. Elles doivent toutes être satisfaites par les BreakRequest de ce BreakRule. Consultez FrequencyConstraint.

BreakRequest

La séquence de pauses (c'est-à-dire leur nombre et leur ordre) qui s'applique à chaque véhicule doit être connue à l'avance. Les BreakRequest répétés définissent cette séquence, dans l'ordre dans lequel ils doivent se produire. Leurs périodes (earliestStartTime/latestStartTime) peuvent se chevaucher, mais elles doivent être compatibles avec la commande (ce qui est vérifié).

Représentation JSON 
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
Champs
earliestStartTime

string (Timestamp format)

Obligatoire. Limite inférieure (inclusive) du début de la pause.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
latestStartTime

string (Timestamp format)

Obligatoire. Limite supérieure (inclusive) du début de la pause.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".
minDuration

string (Duration format)

Obligatoire. Durée minimale de la pause. Doit être positive.

FrequencyConstraint

Vous pouvez limiter davantage la fréquence et la durée des pauses spécifiées ci-dessus en appliquant une fréquence de pause minimale, par exemple "Il doit y avoir une pause d'au moins une heure toutes les 12 heures". En supposant que cela puisse être interprété comme "Dans n'importe quelle période glissante de 12 heures, il doit y avoir au moins une pause d'au moins une heure", cet exemple se traduirait par le FrequencyConstraint suivant :

{
   minBreakDuration { seconds: 3600 }         # 1 hour.
   maxInterBreakDuration { seconds: 39600 }  # 11 hours (12 - 1 = 11).
}

Le moment et la durée des pauses dans la solution respecteront toutes ces contraintes, en plus des créneaux horaires et des durées minimales déjà spécifiés dans le BreakRequest.

En pratique, un FrequencyConstraint peut s'appliquer à des pauses non consécutives. Par exemple, la programmation suivante respecte l'exemple "1 h toutes les 12 h" :

  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
Représentation JSON 
{
  "minBreakDuration": string,
  "maxInterBreakDuration": string
}
Champs
minBreakDuration

string (Duration format)

Obligatoire. Durée minimale de la pause pour cette contrainte. Non négatif. Lisez la description de FrequencyConstraint.
maxInterBreakDuration

string (Duration format)

Obligatoire. Durée maximale autorisée pour tout intervalle de temps de l'itinéraire qui n'inclut pas, au moins partiellement, une pause de duration >= minBreakDuration. Doit être positive.

Objectif

Les objectifs remplacent complètement le modèle de coût et sont donc incompatibles avec les coûts préexistants. Chaque objectif correspond à un certain nombre de coûts prédéfinis, par exemple pour les véhicules, les livraisons ou les attributs de transition.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.

Représentation JSON 
{
  "type": enum (Type),
  "weight": number
}
Champs
type

enum (Type)

Type de l'objectif.
weight

number

Poids de cet objectif par rapport aux autres. Il peut s'agir de n'importe quel nombre non négatif. La somme des pondérations ne doit pas nécessairement être égale à 1. La pondération par défaut est de 1,0.

Type

Type d'objectif qui sera mappé à un ensemble de coûts.

Enums
DEFAULT Un ensemble de coûts par défaut sera utilisé pour garantir une solution raisonnable. Remarque : Cet objectif peut être utilisé seul, mais il sera également toujours ajouté avec une pondération de 1,0, comme référence, aux objectifs spécifiés par l'utilisateur, s'il n'est pas déjà présent.
MIN_DISTANCE "MIN". Réduire la distance totale parcourue.
MIN_WORKING_TIME Réduire le temps de travail total, additionné pour tous les véhicules.
MIN_TRAVEL_TIME Identique à ce qui précède, mais en se concentrant uniquement sur le temps de trajet.
MIN_NUM_VEHICLES Réduire le nombre de véhicules utilisés.

DurationDistanceMatrix

Spécifie une matrice de durée et de distance entre les lieux de départ des visites et des véhicules et les lieux d'arrivée des visites et des véhicules.

Représentation JSON 
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
Champs
rows[]

object (Row)

Spécifie les lignes de la matrice de durée et de distance. Il doit comporter autant d'éléments que ShipmentModel.duration_distance_matrix_src_tags.
vehicleStartTag

string

Tag définissant les véhicules auxquels cette matrice de durée et de distance s'applique. Si ce champ est vide, la matrice s'applique à tous les véhicules, et il ne peut y avoir qu'une seule matrice.

Chaque départ de véhicule doit correspondre à une seule matrice, c'est-à-dire qu'un seul de ses champs startTags doit correspondre au champ vehicleStartTag d'une matrice (et de cette matrice uniquement).

Toutes les matrices doivent avoir un vehicleStartTag différent.

Ligne

Spécifie une ligne de la matrice de durée et de distance.

Représentation JSON 
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
Champs
durations[]

string (Duration format)

Valeurs de durée pour une ligne donnée. Il doit comporter autant d'éléments que ShipmentModel.duration_distance_matrix_dst_tags.
meters[]

number

Valeurs de distance pour une ligne donnée. Si aucun coût ni aucune contrainte ne font référence à des distances dans le modèle, ce champ peut être laissé vide. Sinon, il doit comporter autant d'éléments que durations.

TransitionAttributes

Spécifie les attributs des transitions entre deux visites consécutives sur un itinéraire. Plusieurs TransitionAttributes peuvent s'appliquer à la même transition. Dans ce cas, tous les coûts supplémentaires s'additionnent, et la contrainte ou la limite la plus stricte s'applique (selon la sémantique naturelle "ET").

Représentation JSON 
{
  "srcTag": string,
  "excludedSrcTag": string,
  "dstTag": string,
  "excludedDstTag": string,
  "cost": number,
  "costPerKilometer": number,
  "distanceLimit": {
    object (DistanceLimit)
  },
  "delay": string
}
Champs
srcTag

string

Tags définissant l'ensemble des transitions (src->dst) auxquelles ces attributs s'appliquent.

Une visite source ou un démarrage de véhicule correspond si son VisitRequest.tags ou son Vehicle.start_tags contient srcTag ou ne contient pas excludedSrcTag (selon lequel de ces deux champs n'est pas vide).
excludedSrcTag

string

Consultez les srcTag. Soit srcTag, soit excludedSrcTag doit être non vide.
dstTag

string

Une visite de destination ou une fin de véhicule correspond si son VisitRequest.tags ou son Vehicle.end_tags contient dstTag ou ne contient pas excludedDstTag (selon lequel de ces deux champs n'est pas vide).
excludedDstTag

string

Consultez les dstTag. Soit dstTag, soit excludedDstTag doit être non vide.
cost

number

Spécifie un coût pour effectuer cette transition. Cette valeur est exprimée dans la même unité que tous les autres coûts du modèle et ne doit pas être négative. Il s'applique en plus de tous les autres coûts existants.
costPerKilometer

number

Spécifie un coût par kilomètre appliqué à la distance parcourue lors de cette transition. Il s'ajoute à tout Vehicle.cost_per_kilometer spécifié sur les véhicules.
distanceLimit

object (DistanceLimit)

Spécifie une limite pour la distance parcourue lors de cette transition.

Depuis juin 2021, seules les limites souples sont acceptées.
delay

string (Duration format)

Spécifie un délai encouru lors de l'exécution de cette transition.

Ce délai se produit toujours après la fin de la visite source et avant le début de la visite de destination.

ShipmentTypeIncompatibility

Spécifie les incompatibilités entre les envois en fonction de leur shipmentType. L'apparition d'envois incompatibles sur le même itinéraire est limitée en fonction du mode d'incompatibilité.

Représentation JSON 
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
Champs
types[]

string

Liste des types incompatibles. Deux envois ayant des shipment_types différents parmi ceux listés sont "incompatibles".
incompatibilityMode

enum (IncompatibilityMode)

Mode appliqué à l'incompatibilité.

IncompatibilityMode

Modes définissant la manière dont l'apparence des envois incompatibles est limitée sur un même itinéraire.

Enums
INCOMPATIBILITY_MODE_UNSPECIFIED Mode d'incompatibilité non spécifié. Cette valeur ne doit jamais être utilisée.
NOT_PERFORMED_BY_SAME_VEHICLE Dans ce mode, deux envois de types incompatibles ne peuvent jamais partager le même véhicule.
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

Dans ce mode, deux envois de types incompatibles ne peuvent jamais se trouver dans le même véhicule en même temps :

  • Ils ne peuvent partager le même véhicule que si l'un est livré avant que l'autre ne soit récupéré.
  • Lorsque les deux envois sont des collectes uniquement (pas de livraisons) ou des livraisons uniquement (pas de collectes), ils ne peuvent pas partager le même véhicule.

ShipmentTypeRequirement

Spécifie les exigences entre les envois en fonction de leur shipmentType. Les spécificités de l'exigence sont définies par le mode d'exigence.

Représentation JSON 
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
Champs
requiredShipmentTypeAlternatives[]

string

Liste des types de livraison alternatifs requis par dependentShipmentTypes.
dependentShipmentTypes[]

string

Tous les envois avec un type dans le champ dependentShipmentTypes nécessitent qu'au moins un envoi de type requiredShipmentTypeAlternatives soit visité sur le même itinéraire.

REMARQUE : Les chaînes d'exigences telles qu'un shipmentType dépend de lui-même ne sont pas autorisées.
requirementMode

enum (RequirementMode)

Mode appliqué à l'exigence.

RequirementMode

Modes définissant l'apparence des envois dépendants sur un itinéraire.

Enums
REQUIREMENT_MODE_UNSPECIFIED Mode d'exigence non spécifié. Cette valeur ne doit jamais être utilisée.
PERFORMED_BY_SAME_VEHICLE Dans ce mode, tous les envois "dépendants" doivent partager le même véhicule qu'au moins un de leurs envois "requis".
IN_SAME_VEHICLE_AT_PICKUP_TIME

Avec le mode IN_SAME_VEHICLE_AT_PICKUP_TIME, tous les envois "dépendants" doivent avoir au moins un envoi "obligatoire" sur leur véhicule au moment de leur retrait.

Un retrait de colis "dépendant" doit donc comporter :

  • Un envoi "obligatoire" de livraison uniquement livré sur l'itinéraire après, ou
  • Un envoi "obligatoire" récupéré sur l'itinéraire avant lui, et si l'envoi "obligatoire" est associé à une livraison, celle-ci doit être effectuée après la récupération de l'envoi "dépendant".
IN_SAME_VEHICLE_AT_DELIVERY_TIME Comme précédemment, sauf que les envois "dépendants" doivent avoir un envoi "obligatoire" sur leur véhicule au moment de leur livraison.

PrecedenceRule

Règle de priorité entre deux événements (chaque événement correspond à l'enlèvement ou à la livraison d'un envoi) : le "deuxième" événement doit commencer au moins offsetDuration après le début du "premier".

Plusieurs priorités peuvent faire référence aux mêmes événements (ou à des événements associés), par exemple "la prise en charge de B se produit après la livraison de A" et "la prise en charge de C se produit après la prise en charge de B".

De plus, les priorités ne s'appliquent que lorsque les deux envois sont effectués. Sinon, elles sont ignorées.

Représentation JSON 
{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}
Champs
firstIsDelivery

boolean

Indique si le "premier" événement est une livraison.
secondIsDelivery

boolean

Indique si le "deuxième" événement est une livraison.
offsetDuration

string (Duration format)

Décalage entre le "premier" et le "deuxième" événement. Il peut être négatif.
firstIndex

integer

Index d'expédition du "premier" événement. Vous devez spécifier ce champ.
secondIndex

integer

Index d'envoi du "deuxième" événement. Vous devez spécifier ce champ.