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)(即 seconds: 0,nanos: 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(即 seconds: 31536000,nanos: 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。
  • 1 次在 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
    }
  }
}
  • 有三个位置: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_type(请参阅 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 的到达和出发位置,以及车辆的起始和结束位置。

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

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

vehicleStopover

boolean

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

实验性:此字段的行为或存在性将来可能会发生变化。

表示位置的不同方式。以下是互斥字段的列表。在响应中,最多只能设置以下字段之一:
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 之后,则会产生与事件发生时间晚于 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)

此车辆每移动一单位负载一公里的费用。这可用作燃料消耗量的代理变量:如果负荷是重量(以牛顿为单位),则负荷*千米的维度为能量。

实验性功能:如需了解详情,请参阅 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 产生的费用为(下方费用 * 下方载重 * 公里数 + 上方费用 * 上方载重 * 公里数)

  • 过渡 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。

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 小时的滑动时间窗口内,必须至少有一次时长至少为 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 的说明。

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

用于定义这些属性所适用的(来源->目的地)过渡的标记。

当来源访问或车辆启动的 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

指定了不同运输类型之间的运输不兼容性。系统会根据不兼容模式限制同一路线上的不兼容货件。

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

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