ShipmentModel

配送模型包含一组必须由一组车辆执行的配送，同时最大限度地降低总费用，即以下各项的总和：

  • 车辆路线规划费用（所有车辆的总时间费用、行程时间费用和固定费用之和）。
  • 未履行的配送惩罚。
  • 全球配送时长的费用
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
}
字段
shipments[]

object (Shipment)

必须在模型中执行的一组配送。
vehicles[]

object (Vehicle)

可用于执行拜访的一组车辆。
objectives[]

object (Objective)

此模型的目标集，我们将转换为费用。如果非空，则输入模型必须是无成本的。如需获取修改后的请求，请使用 solvingMode = TRANSFORM_AND_RETURN_REQUEST。请注意，在这种情况下，请求将无法得到解决。请参阅相应文档。

实验性：如需了解详情，请参阅 https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request。
globalStartTime

string (Timestamp format)

模型的全局开始时间和结束时间：此范围之外的任何时间都将被视为无效。

模型的时间跨度必须小于一年，即 globalEndTime 和 globalStartTime 之间的间隔必须在 31536000 秒以内。

使用 cost_per_*hour 字段时，您可能需要将此时间范围设置为较小的间隔，以提高性能（例如，如果您对单天进行建模，则应将全局时间限制设置为该天）。如果未设置，则默认使用世界协调时间 (UTC) 1970 年 1 月 1 日 00:00:00（即秒数：0，纳秒数：0）。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
globalEndTime

string (Timestamp format)

如果未设置，则默认使用 1971 年 1 月 1 日 00:00:00 UTC（即秒数：31536000，纳秒数：0）。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
globalDurationCostPerHour

number

总体方案的“全局时长”是所有车辆的最早有效开始时间与最晚有效结束时间之间的差值。例如，用户可以为该数量分配每小时费用，以尝试优化最早的作业完成时间。此费用的单位必须与 Shipment.penalty_cost 相同。
durationDistanceMatrices[]

object (DurationDistanceMatrix)

指定模型中使用的时长和距离矩阵。如果此字段为空，系统会改用 Google 地图或测地距离，具体取决于 useGeodesicDistances 字段的值。如果此字段不为空，则 useGeodesicDistances 不能为 true，且 durationDistanceMatrixSrcTags 和 durationDistanceMatrixDstTags 都不能为空。

用法示例：

  • 有两个位置：locA 和 locB。
  • 1 辆车从 locA 出发，最后返回 locA。
  • 在 locB 有 1 个取件请求。
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
    }
  }
}
  • 有三个位置：locA、locB 和 locC。
  • 1 辆车从 locA 出发，在 locB 结束路线，使用矩阵“fast”。
  • 1 辆车从 locB 出发，在 locB 结束行程，使用“慢速”矩阵。
  • 1 辆车从 locB 出发，在 locB 结束行程，使用矩阵“fast”。
  • locC 处有 1 个取件访问请求。
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

定义时长和距离矩阵来源的标记；durationDistanceMatrices(i).rows(j) 定义了从具有标记 durationDistanceMatrixSrcTags(j) 的访问到矩阵 i 中其他访问的时长和距离。

代码对应于 VisitRequest.tags 或 Vehicle.start_tags。给定的 VisitRequest 或 Vehicle 必须与此字段中的一个标记完全匹配。请注意，Vehicle 的来源、目标和矩阵标记可能相同；同样，VisitRequest 的来源和目标标记也可能相同。所有标记都必须不同，且不能是空字符串。如果此字段不为空，则 durationDistanceMatrices 不得为空。
durationDistanceMatrixDstTags[]

string

定义时长和距离矩阵目的地的标记；durationDistanceMatrices(i).rows(j).durations(k)（或durationDistanceMatrices(i).rows(j).meters(k)) 定义了矩阵 i 中从具有标记 durationDistanceMatrixSrcTags(j) 的访问到具有标记 durationDistanceMatrixDstTags(k) 的访问的行程时长（或距离）。

代码对应于 VisitRequest.tags 或 Vehicle.start_tags。给定的 VisitRequest 或 Vehicle 必须与此字段中的一个标记完全匹配。请注意，Vehicle 的来源、目标和矩阵标记可能相同；同样，VisitRequest 的来源和目标标记也可能相同。所有标记都必须不同，且不能是空字符串。如果此字段不为空，则 durationDistanceMatrices 不得为空。
transitionAttributes[]

object (TransitionAttributes)

添加到模型中的过渡属性。
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

不兼容的 shipment_types 集合（请参阅 ShipmentTypeIncompatibility）。
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

shipmentType 要求集（请参阅 ShipmentTypeRequirement）。
precedenceRules[]

object (PrecedenceRule)

必须在模型中强制执行的一组优先级规则。

重要提示：使用优先规则会限制可优化的问题规模。如果请求使用的优先规则包含许多配送，则可能会被拒绝。
maxActiveVehicles

integer

限制活跃车辆数量上限。如果车辆的路线至少执行一次配送，则该车辆处于活跃状态。如果司机数量少于车辆数量，且车队中的车辆类型多样，则可以使用此功能来限制路线数量。然后，优化功能会选择要使用的最佳车辆子集。必须严格为正值。

发货

单件物品从一个取件点到送货点的运输过程。为了让系统将配送视为已执行，必须由一辆唯一的车辆访问其某个取货地点（并相应地减少其剩余容量），然后访问其某个送货地点（并相应地重新增加其剩余容量）。

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
}
字段
displayName

string

用户定义的运单显示名称。名称不得超过 63 个字符，且可以使用 UTF-8 字符。
pickups[]

object (VisitRequest)

与配送相关的一组自提替代方案。如果未指定，则车辆只需访问与送货对应的地点。
deliveries[]

object (VisitRequest)

与配送相关的一组备选配送方式。如果未指定，车辆只需访问与取货对应的地点。
loadDemands

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

配送的负载需求（例如重量、体积、托盘数量等）。映射中的键应为描述相应负载类型的标识符，最好还包含单位。例如：“weight_kg”“volume_gallons”“pallet_count”等。如果给定键未出现在映射中，则相应的负载会被视为 null。
allowedVehicleIndices[]

integer

可能执行此配送的一组车辆。如果为空，则所有车辆都可以执行该任务。车辆由其在 ShipmentModel 的 vehicles 列表中的索引指定。
costsPerVehicle[]

number

指定每辆车配送此运单时产生的费用。如果指定，则必须满足以下任一条件：

  • costsPerVehicleIndices 具有相同数量的元素。costsPerVehicle[i] 对应于模型的车辆 costsPerVehicleIndices[i]。
  • 元素数量与模型中的车辆数量相同。第 i 个元素对应于模型的第 i 辆车。

这些费用的单位必须与 penaltyCost 相同，且不得为负数。如果没有此类费用，请将此字段留空。
costsPerVehicleIndices[]

integer

costsPerVehicle 适用的车辆的索引。如果非空，则必须与 costsPerVehicle 具有相同数量的元素。车辆索引只能指定一次。如果车辆被排除在 costsPerVehicleIndices 之外，其费用为零。
pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

指定与从接车点到送车点的最短路径相比，绝对绕行时间上限。如果指定，则必须为非负数，并且运单必须至少包含一个取件和一个送件。

例如，假设 t 是从所选备选取货点直接前往所选备选送货点所需的最短时间。然后，设置 pickupToDeliveryAbsoluteDetourLimit 会强制执行以下操作：

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

如果对同一运单同时指定了相对限制和绝对限制，则对于每种可能的取件/送件组合，系统会采用限制性更强的限制。自 2017 年 10 月起，仅当行程时长不取决于车辆时，才支持绕行。
pickupToDeliveryTimeLimit

string (Duration format)

指定从开始取货到开始送货的最长时长。如果指定，则必须为非负数，并且运单必须至少包含一个取件和一个送件。这不取决于为取货和送货选择的备选方案，也不取决于车辆速度。此约束条件可以与最大绕行约束条件一起指定：解决方案将同时遵循这两项规范。
shipmentType

string

非空字符串，用于指定此配送的“类型”。此功能可用于定义 shipment_types 之间的不兼容性或要求（请参阅 ShipmentModel 中的 shipmentTypeIncompatibilities 和 shipmentTypeRequirements）。

与为单次造访指定的 visitTypes 不同：属于同一配送的所有取件/送货都共用同一个 shipmentType。
label

string

为此配送指定标签。此标签会在响应中相应 ShipmentRoute.Visit 的 shipmentLabel 中报告。
ignore

boolean

如果为 true，则跳过此运单，但不应用 penaltyCost。

如果模型中存在任何 shipmentTypeRequirements，忽略运单会导致验证错误。

允许忽略在 injectedFirstSolutionRoutes 或 injectedSolutionConstraint 中执行的配送；求解器会从执行路线中移除相关的取件/送货。引用被忽略运单的 precedenceRules 也会被忽略。
penaltyCost

number

如果配送未完成，此惩罚会添加到路线的总费用中。如果访问了某个运单的其中一个取件和送货备选方案，则该运单会被视为已完成。费用可以用模型中所有其他费用相关字段所用的相同单位表示，并且必须为正数。

重要提示：如果未指定此惩罚，则系统会将其视为无限，即必须完成配送。
pickupToDeliveryRelativeDetourLimit

number

指定与从上车点到下车点的最短路径相比，相对绕行时间上限。如果指定，则必须为非负数，并且运单必须至少包含一个取件和一个送件。

例如，假设 t 是从所选备选取货点直接前往所选备选送货点所需的最短时间。然后，设置 pickupToDeliveryRelativeDetourLimit 会强制执行以下操作：

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

如果对同一运单同时指定了相对限制和绝对限制，则对于每种可能的取件/送件组合，系统会采用限制性更强的限制。自 2017 年 10 月起，仅当行程时长不取决于车辆时，才支持绕行。

VisitRequest

可由车辆完成的造访请求：它有一个地理位置（或两个，见下文）、由时间窗口表示的开放和关闭时间，以及服务时长（车辆到达后取货或送货所花费的时间）。

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
}
字段
arrivalLocation

object (LatLng)

执行此 VisitRequest 时车辆到达的地理位置。如果配送模型具有时长距离矩阵，则不得指定 arrivalLocation。
arrivalWaypoint

object (Waypoint)

车辆在执行此 VisitRequest 时到达的航点。如果配送模型具有时长距离矩阵，则不得指定 arrivalWaypoint。
departureLocation

object (LatLng)

车辆在完成此 VisitRequest 后出发的地理位置。如果与 arrivalLocation 相同，则可以省略。如果配送模型具有时长距离矩阵，则不得指定 departureLocation。
departureWaypoint

object (Waypoint)

车辆在完成此 VisitRequest 后离开的航点。如果与 arrivalWaypoint 相同，则可以省略。如果配送模型具有时长距离矩阵，则不得指定 departureWaypoint。
tags[]

string

指定附加到访问请求的标记。不允许使用空字符串或重复字符串。
timeWindows[]

object (TimeWindow)

限制到访时间的时间窗口。请注意，车辆可能会在到达时间窗口之外离开，即到达时间 + 持续时间无需在时间窗口内。如果车辆在 TimeWindow.start_time 之前到达，则可能会产生等待时间。

如果缺少 TimeWindow，则表示车辆可以随时执行此访问。

时间窗口必须不相交，即任何时间窗口都不得与其他时间窗口重叠或相邻，并且必须按递增顺序排列。

只有在存在单个时间窗口时，才能设置 costPerHourAfterSoftEndTime 和 softEndTime。
duration

string (Duration format)

到访时长，即车辆在到达和离开之间花费的时间（要添加到可能的等待时间中；请参阅 timeWindows）。
cost

number

在车辆路线上为此访问请求提供服务的费用。这可用于为每种替代自提或送货方式支付不同的费用。此费用必须与 Shipment.penalty_cost 采用相同的单位，且不得为负数。
loadDemands

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

此访问请求的负载需求。这与 Shipment.load_demands 字段类似，只是它仅适用于此 VisitRequest，而不适用于整个 Shipment。此处列出的需求会添加到 Shipment.load_demands 中列出的需求中。
visitTypes[]

string

指定访问类型。这可用于分配车辆完成此访问所需的额外时间（请参阅 Vehicle.extra_visit_duration_for_visit_type）。

一种类型只能出现一次。
label

string

为此 VisitRequest 指定标签。此标签在响应中报告为相应 ShipmentRoute.Visit 中的 visitLabel。
avoidUTurns

boolean

指定在此位置的驾车路线中是否应避免掉头。系统会尽力避免掉头，但无法保证完全避免。这是一项实验性功能，其行为可能会发生变化。

实验性：如需了解详情，请参阅 https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request。

LatLng

表示纬度/经度对的对象。该对象以一对双精度数表示，分别代表纬度度数和经度度数。除非另有说明，否则该对象必须符合 WGS84 标准。值必须介于标准化范围内。

JSON 表示法 
{
  "latitude": number,
  "longitude": number
}
字段
latitude

number

纬度（以度为单位）。它必须在 [-90.0, +90.0] 范围内。
longitude

number

经度（以度为单位）。它必须在 [-180.0, +180.0] 范围内。

航点

封装航点。航点用于标记 VisitRequest 的到达和出发位置，以及 Vehicle 的起始和结束位置。

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.
}
字段
sideOfRoad

boolean

可选。表示此航点的位置旨在让车辆优先停靠在道路的特定一侧。设置此值后，路线将经过该位置，以便车辆可以在该位置偏向道路中心的一侧停车。此选项不适用于“WALKING”出行方式。
vehicleStopover

boolean

表示航点是供车辆停靠的，目的是接载或下客。此选项仅适用于“DRIVING”出行方式，且“locationType”为“location”。

实验性：此字段的行为或存在情况将来可能会发生变化。
表示位置的不同方式。以下是互斥字段的列表。在响应中，最多只能设置以下字段之一：
location

object (Location)

使用地理坐标指定的点，包括可选的朝向。
placeId

string

与航点关联的地图注点地点 ID。

使用地点 ID 指定 VisitRequest 的到达或出发地点时，请使用足够具体的地点 ID，以便确定用于导航到该地点的 LatLng 位置。例如，代表建筑物的地点 ID 是合适的，但不建议使用代表道路的地点 ID。
互斥字段结束。

位置

封装一个位置（一个地理位置点和一个可选的朝向）。

JSON 表示法 
{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}
字段
latLng

object (LatLng)

航点的地理坐标。
heading

integer

与车流方向关联的罗盘航向。此值用于指定上车和下车时使用的道路一侧。朝向值可以介于 0 到 360 之间，其中 0 表示正北，90 表示正东，以此类推。

TimeWindow

时间窗口会限制事件的时间，例如到访时间或车辆的开始和结束时间。

硬性时间窗口边界 startTime 和 endTime 强制执行事件的最早和最晚时间，使得 startTime <= event_time <= endTime。软时间窗口下限 softStartTime 表示，如果事件在 softStartTime 或之后发生，则会产生与事件在 softStartTime 之前发生的时间成正比的费用。软时间窗口上限 softEndTime 表示希望事件在 softEndTime 或之前发生，因为事件在 softEndTime 之后发生的时间越长，产生的费用就越高。startTime、endTime、softStartTime 和 softEndTime 应在全局时间限制内（请参阅 ShipmentModel.global_start_time 和 ShipmentModel.global_end_time），并应遵循以下要求：

  0 <= `startTime` <= `endTime` and
  0 <= `startTime` <= `softStartTime` and
  0 <= `softEndTime` <= `endTime`.
JSON 表示法 
{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}
字段
startTime

string (Timestamp format)

硬性时间窗口开始时间。如果未指定，则会设置为 ShipmentModel.global_start_time。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
endTime

string (Timestamp format)

硬性时间窗口结束时间。如果未指定，则会设置为 ShipmentModel.global_end_time。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
softStartTime

string (Timestamp format)

时间窗口的软开始时间。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
softEndTime

string (Timestamp format)

时间窗口的软结束时间。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
costPerHourBeforeSoftStartTime

number

如果事件发生在 softStartTime 之前，则会向模型中的其他费用添加每小时费用，计算公式如下：

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

此费用必须为正数，并且只有在设置了 softStartTime 的情况下才能设置此字段。
costPerHourAfterSoftEndTime

number

如果事件发生在 softEndTime 之后，则添加到模型中其他费用的小时费用，计算公式如下：

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

此费用必须为正数，并且只有在设置了 softEndTime 的情况下才能设置此字段。

交通工具

为配送问题中的车辆建模。解决配送问题将为此车辆构建一条从 startLocation 开始到 endLocation 结束的路线。路线是一系列到访（请参阅 ShipmentRoute）。

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
}
字段
displayName

string

用户定义的车辆显示名称。名称不得超过 63 个字符，且可以使用 UTF-8 字符。
travelMode

enum (TravelMode)

出行方式，会影响车辆可使用的道路及其速度。另请参阅 travelDurationMultiple。
routeModifiers

object (RouteModifiers)

一组需要满足的条件，这些条件会影响给定车辆的路线计算方式。
startLocation

object (LatLng)

车辆在取任何货物之前启动的地理位置。如果未指定，则车辆从其第一个取货点开始。如果配送模型具有时长和距离矩阵，则不得指定 startLocation。
startWaypoint

object (Waypoint)

表示车辆在取任何货物之前出发的地理位置的航点。如果既未指定 startWaypoint，也未指定 startLocation，则车辆会从其第一个上车点开始。如果配送模型具有时长和距离矩阵，则不得指定 startWaypoint。
endLocation

object (LatLng)

车辆完成最后一次VisitRequest后结束行程的地理位置。如果未指定，则车辆的 ShipmentRoute 会在完成最后一个 VisitRequest 后立即结束。如果配送模型具有时长和距离矩阵，则不得指定 endLocation。
endWaypoint

object (Waypoint)

表示车辆在完成最后一个 VisitRequest 后结束行程的地理位置的航点。如果 endWaypoint 和 endLocation 均未指定，则车辆的 ShipmentRoute 会在完成最后一个 VisitRequest 后立即结束。如果配送模型具有时长和距离矩阵，则不得指定 endWaypoint。
startTags[]

string

指定附加到车辆路线起点的标记。

不允许使用空字符串或重复字符串。
endTags[]

string

指定附加到车辆路线末尾的标记。

不允许使用空字符串或重复字符串。
startTimeWindows[]

object (TimeWindow)

车辆可以从其起始位置出发的时间范围。它们必须在全局时间限制内（请参阅 ShipmentModel.global_* 字段）。如果未指定，则除了这些全局时间限制之外，没有其他限制。

属于同一重复字段的时间窗口必须不相交，即任何时间窗口都不能与其他时间窗口重叠或相邻，并且它们必须按时间顺序排列。

只有在存在单个时间窗口时，才能设置 costPerHourAfterSoftEndTime 和 softEndTime。
endTimeWindows[]

object (TimeWindow)

车辆可以到达其结束地点的时间范围。它们必须在全局时间限制内（请参阅 ShipmentModel.global_* 字段）。如果未指定，则除了这些全局时间限制之外，没有其他限制。

属于同一重复字段的时间窗口必须不相交，即任何时间窗口都不能与其他时间窗口重叠或相邻，并且它们必须按时间顺序排列。

只有在存在单个时间窗口时，才能设置 costPerHourAfterSoftEndTime 和 softEndTime。
unloadingPolicy

enum (UnloadingPolicy)

对车辆强制执行的卸载政策。
loadLimits

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

车辆的容量（例如重量、体积、托盘数量）。映射中的键是负载类型的标识符，与 Shipment.load_demands 字段的键一致。如果此映射中缺少给定键，则相应的容量将被视为无限制。
costPerHour

number

车辆费用：所有费用相加，且必须与 Shipment.penalty_cost 采用相同的单位。

车辆路线的每小时费用。此费用适用于路线所用的总时间，包括行程时间、等待时间和到访时间。使用 costPerHour 而不仅仅是 costPerTraveledHour 可能会导致额外的延迟。
costPerTraveledHour

number

车辆路线每行驶一小时的费用。此费用仅适用于路线所用的行程时间（即 ShipmentRoute.transitions 中报告的时间），不包括等待时间和访问时间。
costPerKilometer

number

车辆路线的每公里费用。此费用适用于 ShipmentRoute.transitions 中报告的距离，不适用于从单个 VisitRequest 的 arrivalLocation 到 departureLocation 隐式行驶的任何距离。
fixedCost

number

如果使用此车辆处理配送，则会应用固定费用。
usedIfRouteIsEmpty

boolean

此字段仅适用于路线不配送任何运单的车辆。它指明在这种情况下是否应将车辆视为正在使用中。

如果为 true，则车辆会从其起始位置前往其结束位置，即使它不运送任何货物也是如此，并且系统会考虑其起始位置 -> 结束位置行程所产生的时间和距离费用。

否则，该车辆不会从其起始位置行驶到其结束位置，并且系统不会为此车辆安排任何 breakRule 或延迟（从 TransitionAttributes 开始）。在这种情况下，车辆的 ShipmentRoute 不包含除车辆索引和标签以外的任何信息。
routeDurationLimit

object (DurationLimit)

对车辆路线的总时长施加的限制。在给定的 OptimizeToursResponse 中，车辆的路线时长是其 vehicleEndTime 与 vehicleStartTime 之间的差值。
travelDurationLimit

object (DurationLimit)

对车辆路线的行程时长施加的限制。在给定的 OptimizeToursResponse 中，路线行程时长是其所有 transitions.travel_duration 的总和。
routeDistanceLimit

object (DistanceLimit)

对车辆路线的总距离施加的限制。在给定的 OptimizeToursResponse 中，路线距离是其所有 transitions.travel_distance_meters 的总和。
extraVisitDurationForVisitType

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

指定从 visitTypes 字符串到时长的映射。时长是指在具有指定 visitTypes 的地点进行访问时，除了 VisitRequest.duration 之外还要花费的时间。如果指定了 costPerHour，则此额外访问时长会增加费用。键（即 visitTypes）不能为空字符串。

如果访问请求有多种类型，则系统会为地图中的每种类型添加时长。
breakRule

object (BreakRule)

描述要对此车辆强制执行的休息时间表。如果为空，则不会为此车辆安排休息时间。
label

string

为此车辆指定标签。此标签在响应中报告为相应 ShipmentRoute 的 vehicleLabel。
ignore

boolean

如果为 true，则 usedIfRouteIsEmpty 必须为 false，并且此车辆将保持未使用状态。

如果配送由 injectedFirstSolutionRoutes 中被忽略的车辆执行，则在第一个解决方案中会跳过该配送，但在响应中可以自由执行。

如果行程由 injectedSolutionConstraint 中被忽略的车辆执行，并且任何相关的取件/送件都受限于留在车辆上（即未放宽到级别 RELAX_ALL_AFTER_THRESHOLD），则会在响应中跳过该行程。如果某个运送具有非空 allowedVehicleIndices 字段，并且所有允许的车辆都被忽略，则系统会在响应中跳过该运送。
travelDurationMultiple

number

指定一个乘数因子，可用于增加或减少此车辆的行程时间。例如，如果将此值设置为 2.0，则表示此车辆速度较慢，行程时间是标准车辆的两倍。此倍数不会影响访问时长。如果指定了 costPerHour 或 costPerTraveledHour，则会影响费用。此值必须在 [0.001, 1000.0] 范围内。如果未设置，则车辆为标准车辆，此倍数视为 1.0。

警告：在应用此倍数之后但在执行任何数值运算之前，行程时间将四舍五入到最接近的秒数，因此，较小的倍数可能会导致精度损失。

另请参阅下文中的 extraVisitDurationForVisitType。

TravelMode

车辆可以使用的出行方式。

这些应是 Google Maps Platform Routes API 出行方式的子集，请参阅：https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode

注意：WALKING路线功能目前处于 Beta 版阶段，有时可能无法提供畅通无阻的人行道或步道。对于应用中显示的所有步行路线，您都必须向用户显示此警告。

枚举
TRAVEL_MODE_UNSPECIFIED 未指定的出行方式，等同于 DRIVING。
DRIVING 与行车路线对应的出行方式（汽车…）。
WALKING 与步行路线对应的出行方式。
TWO_WHEELER 双轮机动车。例如，摩托车。请注意，这与 BICYCLING 出行方式不同，后者涵盖人力驱动模式。只有支持双轮机动车的国家和地区中列出的国家/地区支持此出行方式。

RouteModifiers

封装一组在计算车辆路线时要满足的可选条件。这与 Google Maps Platform Routes Preferred API 中的 RouteModifiers 类似；请参阅：https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers。

JSON 表示法 
{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}
字段
avoidTolls

boolean

指定是否在合理的情况下避开收费路段。系统会优先选择不含收费路段的路线。仅适用于机动出行方式。
avoidHighways

boolean

指定是否在合理的情况下避开高速公路。系统会优先选择不包含高速公路的路线。仅适用于机动出行方式。
avoidFerries

boolean

指定是否在合理的情况下避开轮渡。系统会优先选择不包含轮渡行程的路线。仅适用于机动出行方式。
avoidIndoor

boolean

可选。指定是否在合理的情况下避免室内导航。系统会优先选择不包含室内导航的路线。仅适用于 WALKING 出行方式。

UnloadingPolicy

关于如何卸载车辆的政策。仅适用于同时具有取件和送货环节的运单。

其他配送可以独立于 unloadingPolicy 在路线上的任何位置进行。

枚举
UNLOADING_POLICY_UNSPECIFIED 未指定的卸货政策；送货必须在相应的取货之后进行。
LAST_IN_FIRST_OUT 配送顺序必须与取件顺序相反
FIRST_IN_FIRST_OUT 送货顺序必须与取货顺序相同

LoadLimit

定义适用于车辆的载重限制，例如“此卡车最多只能载重 3500 公斤”。请参阅 loadLimits。

JSON 表示法 
{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string,
  "costPerKilometer": {
    object (LoadCost)
  },
  "costPerTraveledHour": {
    object (LoadCost)
  }
}
字段
softMaxLoad

string (int64 format)

负载的软性限制。请参阅 costPerUnitAboveSoftMax。
costPerUnitAboveSoftMax

number

如果此车辆路线上的负载超过 softMaxLoad，则会应用以下费用惩罚（每辆车仅一次）：(负载 - softMaxLoad) * costPerUnitAboveSoftMax。所有费用都会累加，并且必须与 Shipment.penalty_cost 采用相同的单位。软限制只能在整个模型中仅适用于取货或仅适用于送货的类型上定义。
startLoadInterval

object (Interval)

车辆在路线开始时的可接受载重区间。
endLoadInterval

object (Interval)

车辆在路线结束时的可接受载重区间。
maxLoad

string (int64 format)

可接受的最大负载量。
costPerKilometer

object (LoadCost)

此车辆将一个单位的负载移动一公里所需的费用。这可以用作燃料消耗量的代理：如果负载是重量（以牛顿为单位），则负载*公里具有能量维度。

实验性：如需了解详情，请参阅 https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request。
costPerTraveledHour

object (LoadCost)

此车辆运载一个单位的负载行驶一小时的费用。

实验性：如需了解详情，请参阅 https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request。

间隔

可接受的负载量区间。

JSON 表示法 
{
  "min": string,
  "max": string
}
字段
min

string (int64 format)

可接受的最低负载。必须 ≥ 0。如果同时指定了这两个参数，则 min 必须小于或等于 max。
max

string (int64 format)

可接受的最大负载。必须 ≥ 0。如果未指定，则此消息不会限制最大负载。如果同时指定了这两个参数，则 min 必须小于或等于 max。

LoadCost

在Transition期间移动一个单位的负载所需的费用。对于给定的负载，费用由两部分组成：

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

有了这项费用，解决方案会倾向于先交付高需求，或者最后取货高需求。例如，如果车辆

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

其路线为：开始、取件、取件、送货、送货、结束，并包含以下过渡：

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 }

则此 LoadCost 产生的费用为 (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
  • 转换 2：2.0 * 15 * 1.0 + 10.0 * (20 - 15) * 1.0 = 80.0
  • 转换 3：2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • transition 4: 0.0

因此，路线的 LoadCost 为 120.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 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

则此 LoadCost 产生的费用为

  • transition 0: 0.0
  • transition 1: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • 在第二个转换区停留的时间：0.0
  • 转换 3：2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • transition 4: 0.0

此处，路线上的 LoadCost 为 40.0。

LoadCost 会使具有重载过渡的解决方案更加昂贵。

实验性：如需了解详情，请参阅 https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request。

JSON 表示法 
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
字段
loadThreshold

string (int64 format)

当负载量超过此值时，移动一个单位负载的费用会从 costPerUnitBelowThreshold 变为 costPerUnitAboveThreshold。必须大于等于 0。
costPerUnitBelowThreshold

number

在 0 到阈值之间，移动一个单位的负载所需的费用。必须是有限值，且大于等于 0。
costPerUnitAboveThreshold

number

对于超出阈值的每个单位，移动一个单位负载的费用。在阈值 = 0 的特殊情况下，这是每单位的固定费用。必须是有限值，且大于等于 0。

DurationLimit

定义车辆路线时长上限的限制。可以是硬性或软性。

定义软上限字段时，必须同时定义软上限阈值及其关联的费用。

JSON 表示法 
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
字段
maxDuration

string (Duration format)

一个硬性限制，用于将时长限制为最多 maxDuration。
softMaxDuration

string (Duration format)

软性限制，不强制执行最长时长限制，但违反时会导致路线产生费用。此费用会与模型中定义的其他费用相加，单位相同。

如果已定义，softMaxDuration 必须为非负数。如果还定义了 maxDuration，则 softMaxDuration 必须小于 maxDuration。
quadraticSoftMaxDuration

string (Duration format)

软性限制，不强制执行最长时长限制，但如果违反，则会导致路线产生费用，费用与时长呈二次方关系。此费用会与模型中定义的其他费用相加，单位相同。

如果设置了 quadraticSoftMaxDuration，则必须满足以下条件：

  • 此值必须为非负数。
  • 必须定义 maxDuration。
  • quadraticSoftMaxDuration 必须小于 maxDuration。
  • 差值不得超过一天：maxDuration - quadraticSoftMaxDuration <= 86400 seconds
costPerHourAfterSoftMax

number

如果违反 softMaxDuration 阈值，则会产生每小时费用。如果时长低于阈值，则额外费用为 0，否则费用取决于时长，如下所示：

  costPerHourAfterSoftMax * (duration - softMaxDuration)

费用必须是非负数。
costPerSquareHourAfterQuadraticSoftMax

number

违反 quadraticSoftMaxDuration 阈值时产生的每平方小时费用。

如果时长低于阈值，则额外费用为 0，否则费用取决于时长，如下所示：

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

费用必须是非负数。

DistanceLimit

定义可行驶的最大距离的限制。可以是硬性或软性。

如果定义了软限制，则必须同时定义 softMaxMeters 和 costPerKilometerAboveSoftMax，且两者都必须为非负数。

JSON 表示法 
{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}
字段
maxMeters

string (int64 format)

一个硬性限制，用于将距离限制为最多 maxMeters。限值必须是非负数。
softMaxMeters

string (int64 format)

软性限制，不强制执行最大距离限制，但如果违反，则会产生费用，该费用会与模型中定义的其他费用相加，单位相同。

如果已定义，softMaxMeters 必须小于 maxMeters 且必须为非负数。
costPerKilometerBelowSoftMax

number

产生的每公里费用，最高可达 softMaxMeters，计算公式如下：

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

routeDistanceLimit 不支持此费用。
costPerKilometerAboveSoftMax

number

如果距离超过 softMaxMeters，则会产生每公里费用。如果距离在限制范围内，则额外费用为 0，否则用于计算费用的公式如下：

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

费用必须是非负数。

BreakRule

用于为车辆生成休息时间（例如午休时间）的规则。休息时间是指车辆在当前位置保持空闲且无法执行任何拜访的连续时间段。在以下情况下可能会发生换行：

  • 在两次到访之间的行程期间（包括到访之前或之后的时间，但不包括到访期间），在这种情况下，它会延长到访之间的相应运送时间，
  • 或在车辆开始行程之前（车辆可能不会在休息期间开始行程），在这种情况下，休息时间不会影响车辆开始行程的时间。
  • 或在车辆结束时间之后（同上，使用车辆结束时间）。
JSON 表示法 
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
字段
breakRequests[]

object (BreakRequest)

一系列广告插播时间点。查看 BreakRequest 消息。
frequencyConstraints[]

object (FrequencyConstraint)

可能适用多个FrequencyConstraint。此 BreakRule 的 BreakRequest 必须全部满足这些条件。请参阅 FrequencyConstraint。

BreakRequest

必须事先知道适用于每辆车的休息时间序列（即休息时间的数量和顺序）。重复的 BreakRequest 会按照必须发生的顺序定义该序列。它们的时间窗口（earliestStartTime/latestStartTime）可能会重叠，但必须与订单兼容（系统会对此进行检查）。

JSON 表示法 
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
字段
earliestStartTime

string (Timestamp format)

必需。休息时间开始时间的下限（含）。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
latestStartTime

string (Timestamp format)

必需。休息时间开始时间的上限（含）。

采用 RFC 3339 标准，生成的输出将始终进行 Z 规范化（即转换为 UTC 零时区格式并在末尾附加 Z），并使用 0、3、6 或 9 个小数位。不进行“Z”归一化处理的偏差时间也是可以接受的。示例："2014-10-02T15:01:23Z"、"2014-10-02T15:01:23.045123456Z" 或 "2014-10-02T15:01:23+05:30"。
minDuration

string (Duration format)

必需。广告插播时段的最短时长。必须为正值。

FrequencyConstraint

您可以通过强制执行最短休息频率（例如“每 12 小时必须至少休息 1 小时”）来进一步限制上述休息时间的频率和时长。假设这可以解释为“在任何 12 小时的滑动时间窗口内，必须至少有一次至少一小时的休息时间”，则该示例将转换为以下 FrequencyConstraint：

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

除了 BreakRequest 中已指定的时间范围和最短时长之外，解决方案中休息时间的时间和时长也将遵循所有此类限制。

在实践中，FrequencyConstraint可能适用于非连续休息。例如，以下时间表遵循“每 12 小时 1 小时”示例：

  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
JSON 表示法 
{
  "minBreakDuration": string,
  "maxInterBreakDuration": string
}
字段
minBreakDuration

string (Duration format)

必需。此限制条件对应的最短休息时长。非负。请参阅 FrequencyConstraint 的说明。
maxInterBreakDuration

string (Duration format)

必需。路线中不包含至少部分 duration >= minBreakDuration 休息时间的任何时间间隔的最大允许跨度。必须为正值。

目标

目标会完全取代费用模型，因此与预先存在的费用不兼容。每个目标都会映射到多个预定义费用，例如车辆、配送或过渡属性。

实验性：如需了解详情，请参阅 https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request。

JSON 表示法 
{
  "type": enum (Type),
  "weight": number
}
字段
type

enum (Type)

目标的类型。
weight

number

此目标相对于其他目标应占多大权重。该值可以是任何非负数，权重总和不必为 1。权重默认为 1.0。

类型

将映射到一组费用的目标类型。

枚举
DEFAULT 系统将使用一组默认费用，以确保提供合理的解决方案。注意：此目标可以单独使用，但如果用户指定的目标中尚未包含此目标，系统也会始终以 1.0 的权重将其作为基准添加到用户指定的目标中。
MIN_DISTANCE “MIN”目标。最大限度地缩短总行驶距离。
MIN_WORKING_TIME 最大限度地缩短所有车辆的总工作时间。
MIN_TRAVEL_TIME 与上述相同，但仅关注行程时间。
MIN_NUM_VEHICLES 尽可能减少使用的车辆数量。

DurationDistanceMatrix

指定从到访地点和车辆起始位置到到访地点和车辆结束位置的时长和距离矩阵。

JSON 表示法 
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
字段
rows[]

object (Row)

指定时长和距离矩阵的行。它必须具有与 ShipmentModel.duration_distance_matrix_src_tags 一样多的元素。
vehicleStartTag

string

用于定义此时长和距离矩阵适用于哪些车辆的标记。如果为空，则此矩阵适用于所有车辆，并且只能有一个矩阵。

每个车辆起点必须与一个矩阵完全匹配，即其 startTags 字段中必须有一个与某个矩阵（且仅与该矩阵）的 vehicleStartTag 完全匹配。

所有矩阵都必须具有不同的 vehicleStartTag。

行

指定时长和距离矩阵的一行。

JSON 表示法 
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
字段
durations[]

string (Duration format)

给定行的时长值。它必须具有与 ShipmentModel.duration_distance_matrix_dst_tags 一样多的元素。
meters[]

number

给定行的距离值。如果模型中没有费用或限制条件引用距离，则此字段可以留空；否则，其元素数量必须与 durations 相同。

TransitionAttributes

指定路线中两次连续访问之间的过渡属性。多个 TransitionAttributes 可能适用于同一转换：在这种情况下，所有额外费用都会累加，并且会应用最严格的限制或限制（遵循自然“AND”语义）。

JSON 表示法 
{
  "srcTag": string,
  "excludedSrcTag": string,
  "dstTag": string,
  "excludedDstTag": string,
  "cost": number,
  "costPerKilometer": number,
  "distanceLimit": {
    object (DistanceLimit)
  },
  "delay": string
}
字段
srcTag

string

定义这些属性所适用的 (src->dst) 转换集的标记。

当且仅当来源访问或车辆开始位置的 VisitRequest.tags 或 Vehicle.start_tags 包含 srcTag 或不包含 excludedSrcTag（取决于这两个字段中哪个字段不为空）时，该访问或开始位置才匹配。
excludedSrcTag

string

请参阅 srcTag。srcTag 和 excludedSrcTag 中必须且只能有一个不为空。
dstTag

string

当且仅当目的地访问或车辆结束的 VisitRequest.tags 或 Vehicle.end_tags 包含 dstTag 或不包含 excludedDstTag（取决于这两个字段中哪个字段不为空）时，该目的地访问或车辆结束才匹配。
excludedDstTag

string

请参阅 dstTag。dstTag 和 excludedDstTag 中必须且只能有一个不为空。
cost

number

指定执行此转换的费用。此值的单位与模型中所有其他费用的单位相同，且不得为负数。该费用是在所有其他现有费用的基础上收取的。
costPerKilometer

number

指定执行此转换时行驶距离的每公里费用。它会与车辆上指定的任何 Vehicle.cost_per_kilometer 相加。
distanceLimit

object (DistanceLimit)

指定执行此转换时行驶距离的限制。

自 2021 年 6 月起，仅支持软限制。
delay

string (Duration format)

指定执行此转换时产生的延迟。

此延迟始终发生在完成来源访问之后，以及开始目标访问之前。

ShipmentTypeIncompatibility

指定运单之间的不兼容性，具体取决于其 shipmentType。不兼容的运单在同一路线上的出现情况会根据不兼容模式受到限制。

JSON 表示法 
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
字段
types[]

string

不兼容的类型列表。如果两个配送任务在上述属性中存在不同的 shipment_types，则它们“不兼容”。
incompatibilityMode

enum (IncompatibilityMode)

应用于不兼容问题的模式。

IncompatibilityMode

定义如何在同一路线上限制不兼容运单的出现。

枚举
INCOMPATIBILITY_MODE_UNSPECIFIED 未指定不兼容模式。不应使用此值。
NOT_PERFORMED_BY_SAME_VEHICLE 在此模式下，类型不兼容的两项配送绝不能共用同一辆车。
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

在此模式下，类型不兼容的两个配送任务绝不能同时由同一辆车执行：

  • 只有在其中一个订单送达后，另一个订单才会被取件，这样它们才能共用同一辆车。
  • 如果两个配送任务都仅限取货（无送货）或仅限送货（无取货），则它们根本无法共用同一辆车。

ShipmentTypeRequirement

根据运单的 shipmentType 指定运单之间的要求。要求的具体内容由要求模式定义。

JSON 表示法 
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
字段
requiredShipmentTypeAlternatives[]

string

dependentShipmentTypes 所需的备选配送类型列表。
dependentShipmentTypes[]

string

对于 dependentShipmentTypes 字段中具有类型的每个配送，都要求在同一路线上至少访问一个类型为 requiredShipmentTypeAlternatives 的配送。

注意：不允许出现 shipmentType 依赖于自身的要求链。
requirementMode

enum (RequirementMode)

应用于要求的模式。

RequirementMode

定义路线中从属配送的外观的模式。

枚举
REQUIREMENT_MODE_UNSPECIFIED 未指定要求模式。不应使用此值。
PERFORMED_BY_SAME_VEHICLE 在此模式下，所有“依赖”配送必须与至少一个“必需”配送共用同一辆车。
IN_SAME_VEHICLE_AT_PICKUP_TIME

在 IN_SAME_VEHICLE_AT_PICKUP_TIME 模式下，所有“依赖”运单在取货时，其车辆上必须至少有一个“必需”运单。

因此，“依赖”配送取件必须具有以下任一属性：

  • 在路线中，仅限配送的“必需”运单在以下时间之后配送：
  • 在“依赖”运单之前，在路线上取件的“必需”运单；如果“必需”运单有送货，则此送货必须在“依赖”运单取件之后执行。
IN_SAME_VEHICLE_AT_DELIVERY_TIME 与之前相同，只是“依赖”运单在送货时，其车辆上必须有“必需”运单。

PrecedenceRule

两个事件（每个事件都是运单的取件或送货）之间的优先规则：“第二个”事件必须在“第一个”事件开始后至少 offsetDuration 开始。

多个优先顺序可以引用相同（或相关）事件，例如“B 的取货发生在 A 的送货之后”和“C 的取货发生在 B 的取货之后”。

此外，优先级仅在两个配送都执行时适用，否则会被忽略。

JSON 表示法 
{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}
字段
firstIsDelivery

boolean

指明“第一个”事件是否为递送。
secondIsDelivery

boolean

指明“第二个”事件是否为递送。
offsetDuration

string (Duration format)

“第一个”事件与“第二个”事件之间的时间偏移。该值可以为负数。
firstIndex

integer

“第一个”事件的配送索引。必须指定此字段。
secondIndex

integer

“第二个”事件的运单索引。必须指定此字段。