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 字段时，您可能需要将此窗口设置为较小的时间间隔，以提高性能（例如，如果您对单日进行建模，则应将全局时间限制设置为该天）。如果未设置，则使用 1970 年 1 月 1 日 00:00:00 UTC（即秒数：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 辆车从位置 A 开始其路线，并在位置 A 结束。
  • 在 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 结束，使用矩阵“slow”。
  • 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)) 定义了从具有标记 durationDistanceMatrixSrcTags(j) 的访问到具有标记 durationDistanceMatrixDstTags(k) 的访问在矩阵 i 中的出行时长（相应地为出行距离）。

标记对应于 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 月，仅当出行时长不取决于车辆时，系统才支持绕行。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
pickupToDeliveryTimeLimit

string (Duration format)

指定从取件开始到送达开始的货件最长时长。如果指定，则必须为非负值，并且相应货件必须至少包含取货和送货。这并不取决于为取货和送货选择的替代方案，也不取决于车辆速度。此参数可与绕行距离上限约束条件一起指定：解决方案将同时满足这两项规范。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
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）。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
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 的到达和出发位置，以及车辆的起始和结束位置。

JSON 表示法 
{
  "sideOfRoad": boolean,
  "vehicleStopover": boolean,

  // Union field location_type can be only one of the following:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of list of possible types for union field location_type.
}
字段
sideOfRoad

boolean

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

boolean

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

实验性：此字段的行为或存在状态将来可能会发生变化。
联合字段 location_type。表示位置的不同方式。location_type 只能是下列其中一项：
location

object (Location)

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

string

与途经点关联的 POI 地点 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 之前，则会产生与发生时间早于 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，则当车辆完成其最后一次 VisitRequest 时，ShipmentRoute 会立即结束。如果配送模型具有时长和距离矩阵，则不得指定 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 与步行路线对应的出行方式。

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

定义适用于车辆的载重限制，例如“此卡车最多只能载重 3, 500 公斤”。请参阅 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)

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

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

object (LoadCost)

此车辆在 1 小时内运输一个单位的负载所需的费用。

实验性功能：如需了解详情，请参阅 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 产生的费用为（低于成本 * 低于的负荷 * 公里数 + 高于成本 * 高于的负荷 * 公里数）

  • 过渡 0：0.0
  • 过渡 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
  • 过渡 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 产生的费用为

  • 过渡 0：0.0
  • 过渡 1：2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • 过渡 2：0.0
  • 过渡 3：2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • 过渡 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 的硬性限制。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
softMaxDuration

string (Duration format)

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

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

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
quadraticSoftMaxDuration

string (Duration format)

一种不强制执行最长时长限制的软性限制，但如果违反此限制，路线的费用将按时长的二次方计算。此费用会与模型中定义的其他费用相加，单位相同。

如果已定义，quadraticSoftMaxDuration 必须为非负数。如果还定义了 maxDuration，则 quadraticSoftMaxDuration 必须小于 maxDuration，并且差值不得超过一天：

maxDuration - quadraticSoftMaxDuration <= 86400 seconds

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
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)

必需。休息时长的下限。必须为正值。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。

FrequencyConstraint

还可以通过强制执行最小中断频率来进一步限制上述指定的中断频率和时长，例如“每 12 小时必须至少中断 1 小时”。假设这可以解读为“在任何 12 小时的滑动时间窗口内，必须至少有一次时长至少为 1 小时的休息”，那么该示例将转换为以下 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 的说明。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
maxInterBreakDuration

string (Duration format)

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

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。

目标

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

实验性功能：如需了解详情，请参阅 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 相匹配）。

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

行

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

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

string (Duration format)

指定行的时长值。它必须具有与 ShipmentModel.duration_distance_matrix_dst_tags 相同的元素数量。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
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)

指定执行此过渡时产生的延迟。

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

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。

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)

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

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
firstIndex

integer

“第一个”事件的货件指数。必须指定此字段。
secondIndex

integer

“第二个”事件的货件指数。必须指定此字段。