ShipmentModel

รูปแบบการจัดส่งประกอบด้วยชุดการจัดส่งที่ต้องดำเนินการโดยชุดยานพาหนะ โดยลดต้นทุนโดยรวมให้เหลือน้อยที่สุด ซึ่งก็คือผลรวมของรายการต่อไปนี้

  • ค่าใช้จ่ายในการจัดเส้นทางพาหนะ (ผลรวมของค่าใช้จ่ายต่อเวลาทั้งหมด ค่าใช้จ่ายต่อการเดินทาง และค่าใช้จ่ายคงที่ของยานพาหนะทุกคัน)
  • บทลงโทษการจัดส่งที่ไม่สำเร็จ
  • ค่าใช้จ่ายของระยะเวลาการจัดส่งทั่วโลก
การแสดง JSON 
{
  "shipments": [
    {
      object (Shipment)
    }
  ],
  "vehicles": [
    {
      object (Vehicle)
    }
  ],
  "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)

ชุดยานพาหนะที่สามารถใช้เพื่อเข้าชม
globalStartTime

string (Timestamp format)

เวลาเริ่มต้นและสิ้นสุดแบบรวมของโมเดล: ระบบจะไม่ถือว่าเวลาที่อยู่นอกช่วงนี้ถูกต้อง

ช่วงเวลาของโมเดลต้องน้อยกว่า 1 ปี นั่นคือ globalEndTime และ globalStartTime ต้องอยู่ห่างกันไม่เกิน 31536000 วินาที

เมื่อใช้ช่อง cost_per_*hour คุณอาจต้องการตั้งค่ากรอบเวลานี้เป็นช่วงเวลาที่สั้นลงเพื่อเพิ่มประสิทธิภาพ (เช่น หากคุณประมาณ 1 วัน คุณควรตั้งค่าขีดจํากัดเวลาส่วนกลางเป็นวันนั้น) หากไม่ได้ตั้งค่า ระบบจะใช้เวลา 00:00:00 น. UTC ของวันที่ 1 มกราคม 1970 (เช่น วินาที: 0, นาโน: 0) เป็นค่าเริ่มต้น

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและทศนิยมสูงสุด 9 หลัก ตัวอย่างเช่น "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
globalEndTime

string (Timestamp format)

หากไม่ได้ตั้งค่า ระบบจะใช้เวลา 00:00:00 UTC ของวันที่ 1 มกราคม 1971 (เช่น วินาที: 31536000, nanos: 0) เป็นค่าเริ่มต้น

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและทศนิยมสูงสุด 9 หลัก ตัวอย่าง: "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
globalDurationCostPerHour

number

"ระยะเวลาทั่วโลก" ของแผนโดยรวมคือความแตกต่างระหว่างเวลาเริ่มต้นแรกที่มีผลเร็วที่สุดกับเวลาสิ้นสุดที่มีผลล่าสุดของยานพาหนะทุกคัน เช่น ผู้ใช้สามารถกำหนดค่าใช้จ่ายต่อชั่วโมงให้กับจำนวนดังกล่าวเพื่อพยายามเพิ่มประสิทธิภาพเพื่อให้งานเสร็จเร็วที่สุด เป็นต้น ค่าใช้จ่ายนี้ต้องอยู่ในหน่วยเดียวกับ Shipment.penalty_cost
durationDistanceMatrices[]

object (DurationDistanceMatrix)

ระบุเมทริกซ์ระยะเวลาและระยะทางที่ใช้ในโมเดล หากฟิลด์นี้ว่างเปล่า ระบบจะใช้ Google Maps หรือระยะทางตามพิกัดภูมิศาสตร์แทน ทั้งนี้ขึ้นอยู่กับค่าของช่อง useGeodesicDistances หากเว้นว่างไว้ useGeodesicDistances จะเป็น "จริง" ไม่ได้ และทั้ง durationDistanceMatrixSrcTags และ durationDistanceMatrixDstTags จะเว้นว่างไม่ได้

ตัวอย่างการใช้:

  • มีสถานที่ตั้ง 2 แห่ง ได้แก่ locA และ locB
  • ยานพาหนะ 1 คันที่เริ่มเส้นทางที่ locA และสิ้นสุดที่ locA
  • คำขอเข้าชมการรับสินค้า 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
    }
  }
}
  • มีสถานที่ตั้ง 3 แห่ง ได้แก่ locA, locB และ locC
  • ยานพาหนะ 1 คันที่เริ่มเส้นทางที่ locA และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "เร็ว"
  • ยานพาหนะ 1 คันเริ่มต้นเส้นทางที่ locB และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "ช้า"
  • ยานพาหนะ 1 คันเริ่มต้นเส้นทางที่ locB และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "เร็ว"
  • คำขอรับสินค้า 1 รายการที่ locC
model {
  vehicles { startTags: "locA" endTags: "locB" startTags: "fast" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "slow" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "fast" }
  shipments { pickups { tags: "locC" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixSrcTags: "locC"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrixDstTags: "locC"
  durationDistanceMatrices {
    vehicleStartTag: "fast"
    rows {  # from: locA
      durations { seconds: 1000 } meters: 2000 # to: locB
      durations { seconds: 600 }  meters: 1000 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }   meters: 0    # to: locB
      durations { seconds: 700 } meters: 1200 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 702 } meters: 1190 # to: locB
      durations { seconds: 0 }   meters: 0    # to: locC
    }
  }
  durationDistanceMatrices {
    vehicleStartTag: "slow"
    rows {  # from: locA
      durations { seconds: 1800 } meters: 2001 # to: locB
      durations { seconds: 900 }  meters: 1002 # to: locC
    }
    rows {  # from: locB
      durations { seconds: 0 }    meters: 0    # to: locB
      durations { seconds: 1000 } meters: 1202 # to: locC
    }
    rows {  # from: locC
      durations { seconds: 1001 } meters: 1195 # to: locB
      durations { seconds: 0 }    meters: 0    # to: locC
    }
  }
}
durationDistanceMatrixSrcTags[]

string

แท็กที่กำหนดแหล่งที่มาของระยะเวลาและเมทริกซ์ระยะทาง durationDistanceMatrices(i).rows(j) กำหนดระยะเวลาและระยะทางจากการเข้าชมด้วยแท็ก durationDistanceMatrixSrcTags(j) ไปยังการเข้าชมอื่นๆ ในเมทริกซ์ i

แท็กสอดคล้องกับ VisitRequest.tags หรือ Vehicle.start_tags VisitRequest หรือ Vehicle ที่ระบุต้องตรงกับแท็กเพียง 1 รายการในช่องนี้ โปรดทราบว่าแท็กต้นทาง ปลายทาง และเมทริกซ์ของ Vehicle อาจเหมือนกัน และแท็กต้นทางและปลายทางของ VisitRequest ก็อาจเหมือนกัน แท็กทั้งหมดต้องไม่ซ้ำกันและไม่สามารถเป็นสตริงว่างเปล่าได้ หากช่องนี้ไม่ว่าง ต้องระบุ durationDistanceMatrices
durationDistanceMatrixDstTags[]

string

แท็กที่กําหนดปลายทางของเมตริกระยะเวลาและระยะทาง durationDistanceMatrices(i).rows(j).durations(k) (resp. durationDistanceMatrices(i).rows(j).meters(k)) กำหนดระยะเวลา (ระยะทางตอบกลับ) ของการเดินทางจากการเข้าชมด้วยแท็ก durationDistanceMatrixSrcTags(j) ไปจนถึงการเข้าชมด้วยแท็ก durationDistanceMatrixDstTags(k) ในเมทริกซ์ i

แท็กสอดคล้องกับ VisitRequest.tags หรือ Vehicle.start_tags VisitRequest หรือ Vehicle ที่ระบุต้องตรงกับแท็กเพียง 1 รายการในช่องนี้ โปรดทราบว่าแท็กต้นทาง ปลายทาง และแท็กเมตริกซ์ของ Vehicle อาจเหมือนกัน และแท็กต้นทางและปลายทางของ VisitRequest อาจเหมือนกัน แท็กทั้งหมดต้องไม่ซ้ำกันและไม่สามารถเป็นสตริงว่างเปล่าได้ หากช่องนี้ไม่ว่างเปล่า durationDistanceMatrices ต้องไม่ว่างเปล่า
transitionAttributes[]

object (TransitionAttributes)

เพิ่มแอตทริบิวต์ทรานซิชันลงในโมเดล
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

ชุด delivery_types ที่ใช้ร่วมกันไม่ได้ (ดู ShipmentTypeIncompatibility)
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

ชุดข้อกําหนด shipmentType (ดู ShipmentTypeRequirement)
precedenceRules[]

object (PrecedenceRule)

ชุดกฎลําดับความสําคัญที่ต้องบังคับใช้ในโมเดล
maxActiveVehicles

integer

จำกัดจำนวนยานพาหนะที่ใช้งานอยู่สูงสุด ยานพาหนะยังใช้งานอยู่หากเส้นทางมีการจัดส่งอย่างน้อย 1 ครั้ง ซึ่งอาจใช้จำกัดจำนวนเส้นทางในกรณีที่มีจำนวนผู้ขับขี่น้อยกว่ายานพาหนะและยานพาหนะทั้งหมดอยู่คนละที่ จากนั้นการเพิ่มประสิทธิภาพจะเลือกยานพาหนะที่ดีที่สุดที่จะใช้ ต้องเป็นค่าบวก

การจัดส่ง

การจัดส่งสินค้า 1 รายการ ตั้งแต่การไปรับที่ร้าน 1 ครั้งไปจนถึงการจัดส่งสินค้า 1 รายการ เพื่อให้ระบบถือว่ามีการจัดส่งเกิดขึ้น รถคันเดียวต้องไปที่จุดรับสินค้าแห่งหนึ่ง (และลดกำลังการผลิตที่เหลือตามนั้น) จากนั้นไปที่จุดนำส่งแห่งหนึ่งในภายหลัง (และเพิ่มกำลังการผลิตที่เหลือตามนั้นอีกครั้ง)

การแสดง 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" เป็นต้น หากคีย์หนึ่งๆ ไม่ปรากฏในแผนที่ ระบบจะถือว่าการโหลดที่เกี่ยวข้องเป็นค่าว่าง
allowedVehicleIndices[]

integer

ชุดยานพาหนะที่อาจทำการขนส่งนี้ หากเป็นค่าว่าง หมายความว่ารถทุกรุ่นจะดำเนินการได้ ดัชนีระบุยานพาหนะในรายการ vehicles ของ ShipmentModel
costsPerVehicle[]

number

ระบุค่าใช้จ่ายที่เกิดขึ้นเมื่อการจัดส่งครั้งนี้ได้รับการนำส่งโดยยานพาหนะแต่ละคัน หากระบุ แอตทริบิวต์ดังกล่าวต้องมี 2 รายการดังนี้

  • มีจำนวนองค์ประกอบเท่ากับ costsPerVehicleIndices costsPerVehicle[i] สอดคล้องกับยานพาหนะ costsPerVehicleIndices[i] ของรุ่น
  • จำนวนองค์ประกอบเท่ากับยานพาหนะในโมเดล องค์ประกอบที่ i สอดคล้องกับยานพาหนะ #i ของรุ่น

ค่าใช้จ่ายเหล่านี้ต้องอยู่ในหน่วยเดียวกับ penaltyCost และต้องไม่เป็นค่าลบ ปล่อยช่องนี้ว่างไว้หากไม่มีค่าใช้จ่ายดังกล่าว
costsPerVehicleIndices[]

integer

ตัวบอกยานพาหนะที่ใช้ costsPerVehicle หากไม่ใช่ค่าว่าง costsPerVehicle ต้องมีจำนวนองค์ประกอบเท่ากับ costsPerVehicle ระบุดัชนียานพาหนะได้ไม่เกิน 1 ครั้ง หากยานพาหนะไม่รวมอยู่ใน costsPerVehicleIndices ค่าของยานพาหนะจะเป็น 0
pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

ระบุเวลาอ้อมสูงสุดสัมบูรณ์เทียบกับเส้นทางที่สั้นที่สุดตั้งแต่การไปรับจนถึงการนำส่ง หากระบุ จะต้องไม่ใช่มูลค่าติดลบ และการจัดส่งต้องมีบริการรับสินค้าและการจัดส่งเป็นอย่างน้อย

ตัวอย่างเช่น สมมติให้ t เป็นเวลาที่สั้นที่สุดจากทางเลือกการรับสินค้าซึ่งเลือกไว้ไปยังทางเลือกการนำส่งซึ่งเลือกไว้โดยตรง จากนั้นการตั้งค่า pickupToDeliveryAbsoluteDetourLimit จะบังคับใช้สิ่งต่อไปนี้

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

หากระบุทั้งขีดจำกัดแบบสัมพัทธ์และขีดจำกัดสัมบูรณ์ในการจัดส่งเดียวกัน ระบบจะใช้ขีดจำกัดมากกว่าสำหรับคู่รับสินค้า/การนำส่งที่เป็นไปได้แต่ละคู่ ตั้งแต่ปี 2017 เป็นต้นไป ระบบจะรองรับการออกนอกเส้นทางในกรณีที่ระยะเวลาเดินทางไม่ได้ขึ้นอยู่กับยานพาหนะเท่านั้น

ระยะเวลาเป็นวินาทีโดยมีเลขเศษส่วนไม่เกิน 9 หลัก ลงท้ายด้วย "s" เช่น "3.5s"
pickupToDeliveryTimeLimit

string (Duration format)

ระบุระยะเวลาสูงสุดตั้งแต่เริ่มรับพัสดุไปจนถึงเริ่มนำส่งพัสดุ หากระบุ จะต้องไม่ใช่มูลค่าติดลบ และการจัดส่งต้องมีบริการรับสินค้าและการจัดส่งเป็นอย่างน้อย ข้อมูลนี้ไม่ได้ขึ้นอยู่กับทางเลือกอื่นที่เลือกไว้สำหรับการมารับที่ร้านและการจัดส่ง หรือความเร็วของยานพาหนะ ซึ่งสามารถระบุควบคู่กับข้อจำกัดการเปลี่ยนเส้นทางสูงสุด: โซลูชันจะเป็นไปตามข้อกำหนดทั้ง 2 ข้อ

ระยะเวลาเป็นวินาทีโดยมีเลขเศษส่วนไม่เกิน 9 หลัก ลงท้ายด้วย "s" เช่น "3.5s"
shipmentType

string

สตริงที่ไม่ใช่ค่าว่างซึ่งระบุ "ประเภท" สำหรับการจัดส่งนี้ ฟีเจอร์นี้สามารถใช้เพื่อนิยามความไม่เข้ากันหรือข้อกำหนดระหว่าง shipment_types (ดู shipmentTypeIncompatibilities ถึง shipmentTypeRequirements ใน ShipmentModel)

แตกต่างจาก visitTypes ซึ่งระบุไว้สำหรับการเข้าชมครั้งเดียว: การรับ/การนำส่งทั้งหมดที่อยู่ในการจัดส่งเดียวกันจะมี shipmentType เดียวกัน
label

string

ระบุป้ายกำกับสำหรับการจัดส่งนี้ ระบบจะรายงานป้ายกำกับนี้ในการตอบสนองใน shipmentLabel ของ ShipmentRoute.Visit ที่เกี่ยวข้อง
ignore

boolean

หากจริง ให้ข้ามการจัดส่งนี้ แต่อย่าใช้ penaltyCost

การละเว้นการจัดส่งจะทำให้เกิดข้อผิดพลาดในการตรวจสอบเมื่อมี shipmentTypeRequirements ในโมเดล

ระบบอนุญาตให้ละเว้นการจัดส่งที่ดำเนินการใน injectedFirstSolutionRoutes หรือ injectedSolutionConstraint โปรแกรมโซลูชันจะนำการเรียกเข้ารับ/การนำส่งที่เกี่ยวข้องออกจากเส้นทางที่ดำเนินการ precedenceRules ที่จะอ้างอิงการจัดส่งที่ละเว้นก็จะไม่ได้รับการสนใจเช่นกัน
penaltyCost

number

หากการจัดส่งไม่เสร็จสมบูรณ์ ระบบจะเพิ่มค่าปรับนี้ลงในต้นทุนโดยรวมของเส้นทาง การจัดส่งจะถือว่าเสร็จสมบูรณ์หากมีการเลือกมารับที่ร้านหรือจัดส่งทางเลือกอื่น ต้นทุนอาจแสดงเป็นหน่วยเดียวกับที่ใช้สำหรับช่องอื่นๆ ที่เกี่ยวข้องกับต้นทุนทั้งหมดในโมเดลและต้องเป็นค่าบวก

สำคัญ: หากไม่ได้ระบุค่าปรับนี้ ระบบจะถือว่าไม่มีขีดจำกัด ซึ่งหมายความว่าการจัดส่งต้องเสร็จสมบูรณ์
pickupToDeliveryRelativeDetourLimit

number

ระบุเวลาอ้อมสูงสุดแบบสัมพัทธ์เทียบกับเส้นทางที่สั้นที่สุดตั้งแต่การไปรับจนถึงการนำส่ง หากระบุ ต้องไม่เป็นค่าลบ และการจัดส่งต้องมีการรับสินค้าและการนำส่งอย่างน้อย 1 รายการ

เช่น ระบุระยะเวลาที่สั้นที่สุดในการเดินทางจากจุดรับสินค้าที่เลือกไปยังตัวเลือกการจัดส่งที่เลือกโดยตรง จากนั้นการตั้งค่า pickupToDeliveryRelativeDetourLimit จะบังคับใช้ดังนี้

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

หากระบุทั้งขีดจำกัดแบบสัมพัทธ์และแบบสัมบูรณ์ในการจัดส่งเดียวกัน ระบบจะใช้ขีดจำกัดที่จำกัดมากขึ้นสำหรับคู่การรับ/การนำส่งที่เป็นไปได้แต่ละคู่ ตั้งแต่ปี 2017 เป็นต้นไป ระบบจะรองรับการออกนอกเส้นทางในกรณีที่ระยะเวลาเดินทางไม่ได้ขึ้นอยู่กับยานพาหนะเท่านั้น

VisitRequest

คำขอการเข้าชมซึ่งทำได้โดยยานพาหนะ: ยานพาหนะมีตำแหน่งทางภูมิศาสตร์ (หรือ 2 ดูด้านล่าง) เวลาเปิดและปิดซึ่งแสดงเป็นกรอบเวลา และระยะเวลาการให้บริการ (เวลาที่ยานพาหนะใช้เพื่อไปรับหรือส่งสินค้า)

การแสดง 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
}
ช่อง
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)

ระยะเวลาเป็นวินาทีโดยมีเลขเศษส่วนไม่เกิน 9 หลัก ลงท้ายด้วย "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 นี้ ระบบจะรายงานป้ายกำกับนี้ในการตอบกลับเป็น visitLabel ใน ShipmentRoute.Visit ที่เกี่ยวข้อง

LatLng

วัตถุที่แสดงคู่ละติจูด/ลองจิจูด ค่านี้จะแสดงเป็นคู่ของค่าคู่เพื่อแสดงองศาละติจูดและลองจิจูด วัตถุนี้ต้องเป็นไปตามมาตรฐาน WGS84 เว้นแต่จะระบุไว้เป็นอย่างอื่น ค่าต้องอยู่ในช่วงมาตรฐาน

การแสดง JSON 
{
  "latitude": number,
  "longitude": number
}
ช่อง
latitude

number

ละติจูดเป็นองศา โดยต้องอยู่ในช่วง [-90.0, +90.0]
longitude

number

ลองจิจูดเป็นองศา โดยต้องอยู่ในช่วง [-180.0, +180.0]

จุดบอกทาง

บรรจุจุดอ้างอิง จุดสังเกตจะระบุสถานที่มาถึงและออกเดินทางของคำขอเข้าชม รวมถึงสถานที่เริ่มต้นและสิ้นสุดของยานพาหนะ

การแสดง JSON 
{
  "sideOfRoad": 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

ไม่บังคับ บ่งบอกว่าตำแหน่งของการชี้ทางนี้หมายถึงการต้องการให้ยานพาหนะหยุดที่ด้านใดของถนน เมื่อคุณตั้งค่านี้ เส้นทางจะผ่านสถานที่ตั้งเพื่อให้ยานพาหนะหยุดที่ริมถนนซึ่งอยู่ด้านข้างของสถานที่ตั้งจากจุดกึ่งกลางของถนน ตัวเลือกนี้ใช้ไม่ได้กับโหมดการเดินทาง "เดินเท้า"
ฟิลด์สหภาพ location_type วิธีต่างๆ ในการแสดงสถานที่ location_type ต้องเป็นค่าใดค่าหนึ่งต่อไปนี้
location

object (Location)

จุดที่ระบุโดยใช้พิกัดทางภูมิศาสตร์ รวมถึงส่วนหัวที่ไม่บังคับ
placeId

string

รหัสสถานที่ของจุดที่น่าสนใจที่เกี่ยวข้องกับการชี้ทาง

ตำแหน่ง

บรรจุสถานที่ตั้ง (จุดทางภูมิศาสตร์และส่วนหัวที่ไม่บังคับ)

การแสดง 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

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและมีตัวเลขเศษส่วนสูงสุด 9 หลัก ตัวอย่างเช่น "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
endTime

string (Timestamp format)

เวลาสิ้นสุดของกรอบเวลา หากไม่ระบุ ระบบจะตั้งค่าเป็น ShipmentModel.global_end_time

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและมีตัวเลขเศษส่วนสูงสุด 9 หลัก ตัวอย่างเช่น "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
softStartTime

string (Timestamp format)

เวลาเริ่มต้นแบบค่อยเป็นค่อยไปของกรอบเวลา

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและมีตัวเลขเศษส่วนสูงสุด 9 หลัก ตัวอย่าง: "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
softEndTime

string (Timestamp format)

เวลาสิ้นสุดของกรอบเวลา

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและมีตัวเลขเศษส่วนสูงสุด 9 หลัก ตัวอย่างเช่น "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
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 และจะไม่มีผลกับระยะทางที่เดินทางโดยปริยายจาก arrivalLocation ไปยัง departureLocation ของ VisitRequest เดียว
fixedCost

number

ค่าใช้จ่ายคงที่จะมีผลหากใช้ยานพาหนะคันนี้ในการจัดการการจัดส่ง
usedIfRouteIsEmpty

boolean

ช่องนี้จะใช้ได้กับยานพาหนะเมื่อเส้นทางของยานพาหนะนั้นไม่มีการจัดส่ง ข้อมูลนี้ระบุว่าควรพิจารณายานพาหนะเป็นยานพาหนะมือสองหรือไม่ในกรณีนี้

หากเป็นจริง ยานพาหนะจะเดินทางจากจุดเริ่มต้นไปยังตำแหน่งปลายทางแม้ว่าจะไม่ได้ให้บริการจัดส่งใดๆ รวมถึงค่าใช้จ่ายด้านเวลาและระยะทางที่เกิดจากจุดเริ่มต้น --> การเดินทางสิ้นสุด

ไม่เช่นนั้น ยานพาหนะจะไม่เดินทางจากจุดเริ่มต้นไปยังจุดสิ้นสุด และไม่มีการกำหนดเวลา 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 ไปยังระยะเวลา ระยะเวลาคือเวลาเพิ่มเติมจาก VisitRequest.duration ที่ใช้ในการเข้าชมที่มี visitTypes ที่ระบุ ระยะเวลาการเข้าชมเพิ่มเติมนี้จะมีค่าใช้จ่ายหากระบุ costPerHour คีย์ (เช่น visitTypes) จะเป็นสตริงว่างไม่ได้

หากคำขอเข้าชมมีหลายประเภท ระบบจะเพิ่มระยะเวลาสำหรับแต่ละประเภทในแผนที่
breakRule

object (BreakRule)

อธิบายกำหนดช่วงพักที่จะบังคับใช้กับยานพาหนะนี้ หากรถคันนี้ว่างเปล่า ระบบจะไม่กำหนดเวลาพักสำหรับยานพาหนะนี้
label

string

ระบุป้ายกำกับสำหรับยานพาหนะนี้ ระบบจะรายงานป้ายกำกับนี้ในคำตอบเป็น vehicleLabel ของ ShipmentRoute ที่เกี่ยวข้อง
ignore

boolean

หากเป็นจริง usedIfRouteIsEmpty ต้องเป็นเท็จ และยานพาหนะนี้จะยังคงไม่มีการใช้งาน

หากการจัดส่งดำเนินการโดยยานพาหนะที่ละเว้นใน injectedFirstSolutionRoutes ระบบจะข้ามการจัดส่งในโซลูชันแรก แต่จะดำเนินการได้ในคำตอบโดยไม่มีค่าใช้จ่าย

หากการจัดส่งดำเนินการโดยยานพาหนะที่ละเว้นใน injectedSolutionConstraint และมีการจำกัดการรับ/การนำส่งที่เกี่ยวข้องให้อยู่ในยานพาหนะ (กล่าวคือ ไม่ผ่อนปรนเป็นระดับ RELAX_ALL_AFTER_THRESHOLD) ระบบจะข้ามคำตอบนั้น หากการจัดส่งมีช่อง allowedVehicleIndices ที่ไม่ว่างเปล่าและระบบละเว้นยานพาหนะที่อนุญาตทั้งหมด ระบบจะข้ามการจัดส่งนั้นในการตอบกลับ
travelDurationMultiple

number

ระบุตัวคูณที่ใช้เพื่อเพิ่มหรือลดเวลาเดินทางของยานพาหนะคันนี้ เช่น การตั้งค่านี้เป็น 2.0 หมายความว่ายานพาหนะนี้ช้ากว่าและมีเวลาเดินทางเป็น 2 เท่าของยานพาหนะมาตรฐาน จำนวนนี้ไม่มีผลต่อระยะเวลาการเข้าชม แต่จะมีผลต่อต้นทุนหากมีการระบุ costPerHour หรือ costPerTraveledHour ต้องอยู่ในช่วง [0.001, 1000.0] หากไม่ได้ตั้งค่า ยานพาหนะจะเป็นรุ่นมาตรฐาน และตัวคูณนี้จะถือว่าเท่ากับ 1.0

โปรดทราบว่าระบบจะปัดเศษเวลาเดินทางเป็นวินาทีที่ใกล้ที่สุดหลังจากใช้ตัวคูณนี้ แต่ก่อนที่จะดำเนินการทางตัวเลขใดๆ ดังนั้นตัวคูณขนาดเล็กอาจทำให้ความแม่นยำลดลง

ดูข้อมูลเพิ่มเติมได้ที่ extraVisitDurationForVisitType ด้านล่าง

TravelMode

โหมดการเดินทางที่ยานพาหนะใช้ได้

ซึ่งควรเป็นส่วนหนึ่งของโหมดการเดินทางของ Routes Preferred API ของ Google Maps Platform โปรดดู https://developers.google.com/maps/documentation/routes_preferred/reference/rest/Shared.Types/RouteTravelMode

Enum
TRAVEL_MODE_UNSPECIFIED โหมดการเดินทางที่ไม่ระบุ เทียบเท่ากับ DRIVING
DRIVING โหมดการเดินทางที่สอดคล้องกับเส้นทางการขับรถ (รถยนต์ ฯลฯ)
WALKING รูปแบบการเดินทางที่สอดคล้องกับเส้นทางเดินเท้า

RouteModifiers

สรุปชุดเงื่อนไขที่ไม่บังคับเพื่อปฏิบัติตามเมื่อคำนวณเส้นทางของยานพาหนะ ซึ่งคล้ายกับ RouteModifiers ใน Google Maps Platform Routes Preferred API โปรดดู 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

Enum
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 ตลอดเส้นทางของยานพาหนะนี้ ระบบจะหักค่าใช้จ่ายต่อไปนี้ (1 ครั้งต่อยานพาหนะ) (น้ำหนักบรรทุก - softMaxLoad) * costPerUnitAboveSoftMax ค่าใช้จ่ายทั้งหมดจะรวมกันและต้องเป็นหน่วยเดียวกับ Shipment.penalty_cost
startLoadInterval

object (Interval)

ช่วงเวลาของน้ำหนักบรรทุกที่ยอมรับได้ของยานพาหนะเมื่อเริ่มเส้นทาง
endLoadInterval

object (Interval)

ช่วงเวลาการบรรทุกที่ยอมรับได้ของยานพาหนะเมื่อสิ้นสุดเส้นทาง
maxLoad

string (int64 format)

ปริมาณการโหลดสูงสุดที่ยอมรับได้
costPerKilometer

object (LoadCost)

ค่าขนส่งน้ำหนัก 1 หน่วยในระยะทาง 1 กิโลเมตรสำหรับยานพาหนะนี้ ข้อมูลนี้สามารถใช้เป็นพร็อกซีสําหรับปริมาณการใช้เชื้อเพลิงได้ หากน้ำหนักบรรทุกคือน้ำหนัก (เป็นนิวตัน) น้ำหนักบรรทุก*กิโลเมตรจะมีมิติข้อมูลเป็นพลังงาน
costPerTraveledHour

object (LoadCost)

ค่าใช้จ่ายในการเดินทางด้วยน้ำหนักบรรทุก 1 หน่วยเป็นเวลา 1 ชั่วโมงสำหรับยานพาหนะนี้

ช่วงเวลา

ช่วงเวลาของปริมาณการโหลดที่ยอมรับได้

การแสดง JSON 
{
  "min": string,
  "max": string
}
ช่อง
min

string (int64 format)

โหลดต่ำสุดที่ยอมรับได้ ต้องมากกว่า 0 หากระบุทั้ง 2 รายการ min ต้อง ≤ max
max

string (int64 format)

โหลดสูงสุดที่ยอมรับได้ ต้องมากกว่าหรือเท่ากับ 0 หากไม่ได้ระบุ ระบบจะไม่จำกัดน้ำหนักบรรทุกสูงสุดด้วยข้อความนี้ หากระบุไว้ทั้ง 2 อย่าง min ต้อง ≤ max

LoadCost

ค่าใช้จ่ายในการย้ายโหลด 1 หน่วยระหว่าง Transition สำหรับภาระงานหนึ่งๆ ต้นทุนคือผลรวมของ 2 ส่วนดังนี้

  • นาที(โหลด, 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)

  • การเปลี่ยน 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

อย่างไรก็ตาม หากเส้นทางคือ start,pickup,delivery,pickup,delivery,end ที่มีทรานซิชัน

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 ทำให้โซลูชันที่มีทรานซิชันที่มีภาระมากมีราคาแพงขึ้น

การแสดง JSON 
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
ช่อง
loadThreshold

string (int64 format)

จำนวนโหลดข้างต้นซึ่งค่าใช้จ่ายในการย้ายหน่วยของโหลดมีการเปลี่ยนแปลงจาก costPerUnit belowThreshold เป็น costPerUnitAboveThreshold ต้องมากกว่าหรือเท่ากับ 0
costPerUnitBelowThreshold

number

ต้นทุนในการย้ายโหลด 1 หน่วยสําหรับแต่ละหน่วยระหว่าง 0 ถึงเกณฑ์ ต้องเป็นค่าที่แน่นอนและมากกว่าหรือเท่ากับ 0
costPerUnitAboveThreshold

number

ค่าใช้จ่ายในการย้ายหน่วยของโหลดสำหรับแต่ละหน่วยที่สูงกว่าเกณฑ์ ในเกณฑ์กรณีพิเศษ = 0 จำนวนนี้คือต้นทุนต่อหน่วยคงที่ ต้องเป็นค่าที่แน่นอนและมากกว่าหรือเท่ากับ 0

DurationLimit

ขีดจำกัดที่กำหนดระยะเวลาสูงสุดของเส้นทางของยานพาหนะ โดยจะเป็นแบบแข็งหรือเบา

เมื่อกําหนดช่องขีดจํากัดสูงสุดแบบยืดหยุ่น คุณต้องกําหนดทั้งเกณฑ์สูงสุดแบบยืดหยุ่นและต้นทุนที่เกี่ยวข้องร่วมกัน

การแสดง JSON 
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
ช่อง
maxDuration

string (Duration format)

ขีดจำกัดแบบเข้มงวดซึ่งจำกัดระยะเวลาให้อยู่ใน maxDuration

ระยะเวลาเป็นวินาทีโดยมีเลขเศษส่วนไม่เกิน 9 หลัก ลงท้ายด้วย "s" เช่น "3.5s"
softMaxDuration

string (Duration format)

ขีดจํากัดแบบไม่บังคับจะไม่บังคับใช้ขีดจํากัดระยะเวลาสูงสุด แต่หากมีการละเมิด เส้นทางจะมีค่าใช้จ่าย ค่าใช้จ่ายนี้จะบวกกับต้นทุนอื่นๆ ที่กำหนดไว้ในโมเดลด้วยหน่วยเดียวกัน

หากกำหนดไว้ softMaxDuration ต้องไม่เป็นค่าลบ หากกำหนด maxDuration ด้วย softMaxDuration ต้องน้อยกว่า maxDuration

ระยะเวลาเป็นวินาทีโดยมีเลขเศษส่วนไม่เกิน 9 หลัก ลงท้ายด้วย "s" เช่น "3.5s"
quadraticSoftMaxDuration

string (Duration format)

ขีดจำกัดชั่วคราวไม่ได้บังคับใช้ขีดจำกัดระยะเวลาสูงสุด แต่หากมีการละเมิดจะทำให้เส้นทางมีค่าใช้จ่าย เป็นกำลังสองในระยะเวลา ต้นทุนนี้จะรวมกับต้นทุนอื่นๆ ที่กําหนดไว้ในโมเดลซึ่งมีหน่วยเดียวกัน

หากกำหนดไว้ quadraticSoftMaxDuration ต้องไม่เป็นค่าลบ หากมีการกำหนด maxDuration ด้วย quadraticSoftMaxDuration ต้องน้อยกว่า maxDuration และผลต่างต้องไม่เกิน 1 วัน

maxDuration - quadraticSoftMaxDuration <= 86400 seconds

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "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

กฎในการสร้างช่วงพักสำหรับยานพาหนะ (เช่น ช่วงพักกลางวัน) ช่วงพักคือช่วงเวลาต่อเนื่องที่ยานพาหนะไม่ได้ทำงานอยู่ที่ตำแหน่งปัจจุบันและไม่สามารถเข้าชมได้ ช่วงพักอาจเกิดขึ้นในกรณีต่อไปนี้

  • ระหว่างการเดินทางระหว่างการเข้าชม 2 ครั้ง (ซึ่งรวมถึงเวลาก่อนหรือหลังการเข้าชม แต่ไม่ใช่ระหว่างการเข้าชม) ในกรณีนี้ ระบบจะขยายเวลาเดินทางที่เกี่ยวข้องระหว่างการเข้าชม
  • หรือก่อนที่รถจะเริ่มทำงาน (รถอาจไม่สตาร์ทในช่วงพัก) ในกรณีนี้จะไม่ส่งผลต่อเวลาเริ่มต้นของรถ
  • หรือหลังจากท้ายรถ (ตามด้วยเวลาสิ้นสุดของยานพาหนะ)
การแสดง JSON 
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
ช่อง
breakRequests[]

object (BreakRequest)

ลำดับการหยุดพัก ดูข้อความ BreakRequest
frequencyConstraints[]

object (FrequencyConstraint)

อาจมี FrequencyConstraint หลายรายการ ทุกคนต้องพึงพอใจกับBreakRequestของBreakRuleเครื่องนี้ โปรดดูFrequencyConstraint

BreakRequest

คุณต้องทราบลำดับของช่วงพัก (เช่น จำนวนและลำดับ) ที่มีผลกับยานพาหนะแต่ละคันล่วงหน้า BreakRequest ที่ซ้ำกันจะกำหนดลำดับนั้นตามลำดับที่ต้องทำ กรอบเวลา (earliestStartTime / latestStartTime) อาจทับซ้อนกัน แต่จะต้องเข้ากันได้กับลำดับ (เลือกไว้)

การแสดง JSON 
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
ช่อง
earliestStartTime

string (Timestamp format)

ต้องระบุ ขอบเขตล่าง (รวม) ของช่วงพัก

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและมีตัวเลขเศษส่วนสูงสุด 9 หลัก ตัวอย่าง: "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
latestStartTime

string (Timestamp format)

ต้องระบุ ขอบเขตบน (รวม) ของจุดเริ่มต้นของช่วงพัก

การประทับเวลาจะอยู่ในรูปแบบ RFC3339 UTC "Zulu" ที่มีความละเอียดระดับนาโนวินาทีและมีตัวเลขเศษส่วนสูงสุด 9 หลัก ตัวอย่าง: "2014-10-02T15:01:23Z" และ "2014-10-02T15:01:23.045123456Z"
minDuration

string (Duration format)

ต้องระบุ ระยะเวลาขั้นต่ำของช่วงพัก ต้องเป็นค่าบวก

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "s" เช่น "3.5s"

FrequencyConstraint

นอกจากนี้อาจมีการจำกัดความถี่และระยะเวลาของช่วงพักตามที่ระบุไว้ข้างต้นอีก โดยการบังคับใช้ความถี่ของช่วงพักขั้นต่ำ เช่น "ต้องมีช่วงพักอย่างน้อย 1 ชั่วโมงทุก 12 ชั่วโมง" สมมติว่าสามารถแปลค่าเป็น "ภายในกรอบเวลาการเลื่อนที่ 12 ชั่วโมง ต้องมีช่วงพักอย่างน้อย 1 ชั่วโมง" ตัวอย่างดังกล่าวจะแปลเป็น FrequencyConstraint ต่อไปนี้

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

ช่วงเวลาและระยะเวลาของช่วงพักในโซลูชันจะเป็นไปตามข้อจำกัดดังกล่าวทั้งหมด นอกเหนือจากกรอบเวลาและระยะเวลาขั้นต่ำที่ระบุไว้ใน BreakRequest แล้ว

ในทางปฏิบัติ FrequencyConstraint อาจใช้กับช่วงพักที่ไม่ต่อเนื่อง ตัวอย่างเช่น กำหนดการต่อไปนี้เป็นไปตามตัวอย่าง "1 ชั่วโมงทุก 12 ชั่วโมง"

  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

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "s" เช่น "3.5s"
maxInterBreakDuration

string (Duration format)

ต้องระบุ ช่วงเวลาสูงสุดที่อนุญาตของเส้นทางที่ไม่มีช่วงพัก duration >= minBreakDuration อย่างน้อยบางส่วน ต้องเป็นค่าบวก

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "s" เช่น "3.5s"

DurationDistanceMatrix

ระบุระยะเวลาและเมทริกซ์ระยะทางจากการเข้าชมและสถานที่เริ่มต้นของยานพาหนะที่จะเข้าชมและตำแหน่งปลายทางของยานพาหนะ

การแสดง JSON 
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
ช่อง
rows[]

object (Row)

ระบุแถวของเมทริกซ์ระยะเวลาและระยะทาง โดยต้องมีองค์ประกอบเท่ากับ ShipmentModel.duration_distance_matrix_src_tags
vehicleStartTag

string

แท็กที่กําหนดว่าเมตริกระยะเวลาและระยะทางนี้มีผลกับยานพาหนะใด หากเป็นค่าว่าง รายการนี้จะมีผลกับยานพาหนะทุกคัน และจะมีได้เพียงเมทริกซ์เดียวเท่านั้น

จุดเริ่มต้นของยานพาหนะแต่ละคันต้องตรงกับเมทริกซ์ 1 รายการ กล่าวคือ ฟิลด์ startTags ของช่องใดฟิลด์หนึ่งต้องตรงกับ vehicleStartTag ของเมทริกซ์ (และของเมทริกซ์ดังกล่าวเท่านั้น)

เมทริกซ์ทั้งหมดต้องมี vehicleStartTag ที่แตกต่างกัน

แถว

ระบุแถวของเมทริกซ์ระยะเวลาและระยะทาง

การแสดง JSON 
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
ช่อง
durations[]

string (Duration format)

ค่าระยะเวลาของแถวที่กำหนด โดยต้องมีองค์ประกอบเท่ากับ ShipmentModel.duration_distance_matrix_dst_tags

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "s" เช่น "3.5s"
meters[]

number

ค่าระยะทางของแถวหนึ่งๆ หากไม่มีต้นทุนหรือข้อจำกัดที่อ้างอิงถึงระยะทางในโมเดล คุณก็ปล่อยว่างไว้ได้ แต่หากมี องค์ประกอบต้องมีจำนวนเท่ากับ durations

TransitionAttributes

ระบุแอตทริบิวต์ของการเปลี่ยนระหว่างการเข้าชม 2 ครั้งติดต่อกันในเส้นทาง 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 (ขึ้นอยู่กับว่าข้อมูลใดใน 2 ฟิลด์ที่ไม่ว่าง)
excludedSrcTag

string

ดูsrcTag ต้องระบุ srcTag และ excludedSrcTag ที่แน่นอน 1 รายการ
dstTag

string

การเข้าชมปลายทางหรือจุดสิ้นสุดของยานพาหนะตรงกับ VisitRequest.tags หรือ Vehicle.end_tags มี dstTag หรือไม่มี excludedDstTag (ขึ้นอยู่กับว่าฟิลด์ใดใน 2 ฟิลด์นี้ไม่ว่างเปล่า)
excludedDstTag

string

ดูdstTag dstTag และ excludedDstTag ต้องไม่ว่างเปล่าอย่างใดอย่างหนึ่ง
cost

number

ระบุค่าใช้จ่ายในการเปลี่ยนผ่านนี้ ค่านี้อยู่ในรูปแบบเดียวกับค่าใช้จ่ายอื่นๆ ทั้งหมดในโมเดลและต้องไม่ติดลบ โดยจะมีผลเพิ่มเติมจากค่าใช้จ่ายอื่นๆ ทั้งหมดที่มีอยู่
costPerKilometer

number

ระบุต้นทุนต่อกิโลเมตรที่ใช้กับระยะทางที่เดินทางขณะทำการเปลี่ยนนี้ ซึ่งจะรวมกับ Vehicle.cost_per_kilometer ที่ระบุไว้ในยานพาหนะ
distanceLimit

object (DistanceLimit)

ระบุขีดจำกัดของระยะทางในการเดินทางในขณะทำการเปลี่ยนนี้

ตั้งแต่ปี 2021/06 เป็นต้นไป ระบบจะรองรับเฉพาะขีดจำกัดชั่วคราวเท่านั้น
delay

string (Duration format)

ระบุความล่าช้าที่เกิดขึ้นเมื่อทำการเปลี่ยนนี้

การหน่วงเวลานี้จะเกิดขึ้นหลังจากการเข้าชมต้นทางเสร็จสิ้นและก่อนเริ่มต้นการเข้าชมปลายทาง

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "s" เช่น "3.5s"

ShipmentTypeIncompatibility

ระบุความเข้ากันไม่ได้ระหว่างการจัดส่งโดยขึ้นอยู่กับ shipmentType ระบบจะจำกัดการแสดงการจัดส่งที่เข้ากันไม่ได้ในเส้นทางเดียวกันตามโหมดที่เข้ากันไม่ได้

การแสดง JSON 
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
ช่อง
types[]

string

รายการประเภทที่ใช้ร่วมกันไม่ได้ การจัดส่ง 2 รายการที่มี shipment_types แตกต่างกันในแต่ละรายการที่แสดงคือ "ใช้ร่วมกันไม่ได้"
incompatibilityMode

enum (IncompatibilityMode)

ใช้โหมดกับความไม่เข้ากัน

IncompatibilityMode

โหมดที่กําหนดวิธีจํากัดลักษณะที่ปรากฏของการจัดส่งที่เข้ากันไม่ได้ในเส้นทางเดียวกัน

Enum
INCOMPATIBILITY_MODE_UNSPECIFIED โหมดเข้ากันไม่ได้ที่ไม่ระบุ คุณไม่ควรใช้ค่านี้
NOT_PERFORMED_BY_SAME_VEHICLE ในโหมดนี้ การจัดส่ง 2 รายการที่มีประเภทที่ใช้ร่วมกันไม่ได้จะใช้รถคันเดียวกันไม่ได้
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

สำหรับการจัดส่ง 2 รายการที่มีประเภทที่เข้ากันไม่ได้กับโหมดความเข้ากันไม่ได้ของ NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY ให้ทำดังนี้

  • หากทั้ง 2 รายการเป็นการไปรับสินค้าเท่านั้น (ไม่มีการนำส่ง) หรือการนําส่งเท่านั้น (ไม่มีการไปรับสินค้า) รายการดังกล่าวจะใช้ยานพาหนะคันเดียวกันไม่ได้เลย
  • หากการจัดส่งรายการหนึ่งเป็นการนําส่งและอีกรายการเป็นการไปรับ การจัดส่งทั้ง 2 รายการจะใช้ยานพาหนะคันเดียวกันได้ก็ต่อเมื่อมีการนําส่งการจัดส่งรายการแรกก่อนมีการไปรับการจัดส่งรายการที่ 2

ShipmentTypeRequirement

ระบุข้อกำหนดระหว่างการจัดส่งตาม shipmentType ข้อมูลจำเพาะของข้อกำหนดจะกำหนดโดยโหมดข้อกำหนด

การแสดง JSON 
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
ช่อง
requiredShipmentTypeAlternatives[]

string

รายการประเภทการจัดส่งทางเลือกที่ dependentShipmentTypes กำหนด
dependentShipmentTypes[]

string

การจัดส่งทั้งหมดที่มีประเภทในช่อง dependentShipmentTypes ต้องมีการจัดส่งประเภท requiredShipmentTypeAlternatives อย่างน้อย 1 รายการในเส้นทางเดียวกัน

หมายเหตุ: ไม่อนุญาตให้ใช้เชนของข้อกำหนดที่ shipmentType ต้องพึ่งพาตัวเอง
requirementMode

enum (RequirementMode)

โหมดที่ใช้กับข้อกําหนด

RequirementMode

รูปแบบที่กำหนดลักษณะของการจัดส่งแบบพึ่งพาบนเส้นทาง

Enum
REQUIREMENT_MODE_UNSPECIFIED โหมดข้อกำหนดที่ไม่ได้ระบุ ไม่ควรใช้ค่านี้
PERFORMED_BY_SAME_VEHICLE ในโหมดนี้ การจัดส่ง "ที่ต้องอาศัย" ทั้งหมดต้องใช้ยานพาหนะเดียวกันกับการจัดส่ง "ที่ต้องใช้" อย่างน้อย 1 รายการ
IN_SAME_VEHICLE_AT_PICKUP_TIME

เมื่อใช้โหมด IN_SAME_VEHICLE_AT_PICKUP_TIME การจัดส่งที่ "ขึ้นอยู่กับ" ทั้งหมดต้องมีการจัดส่งที่ "จำเป็น" อย่างน้อย 1 รายการบนยานพาหนะ ณ เวลาไปรับ

ดังนั้น บริการรับสินค้าที่ "ต้องพึ่งพา" จึงต้องมีอย่างใดอย่างหนึ่งต่อไปนี้

  • การจัดส่งที่ "จำเป็น" แบบเฉพาะจัดส่งที่นำส่งในเส้นทางหลังจากนั้น หรือ
  • มีการไปรับพัสดุที่ "จำเป็น" ในเส้นทางก่อนหน้า และหากการจัดส่งที่ "จำเป็น" มีการนำส่ง จะต้องดำเนินการหลังจากการไปรับพัสดุที่ "ต้องพึ่งพา"
IN_SAME_VEHICLE_AT_DELIVERY_TIME เช่นเดียวกับก่อนหน้านี้ ยกเว้นการจัดส่งที่ "ขึ้นอยู่กับ" จะต้องมีการจัดส่งที่ "จำเป็น" ในยานพาหนะ ณ เวลาที่นำส่ง

PrecedenceRule

กฎลําดับความสําคัญระหว่าง 2 เหตุการณ์ (แต่ละเหตุการณ์คือการไปรับหรือการนำส่งการจัดส่ง): เหตุการณ์ "ที่ 2" ต้องเริ่มต้นหลังจากเหตุการณ์ "ที่ 1" เริ่มต้นอย่างน้อย offsetDuration

ลําดับความสําคัญหลายรายการอาจอ้างอิงถึงเหตุการณ์เดียวกัน (หรือที่เกี่ยวข้อง) เช่น "การรับสินค้า ข เกิดขึ้นหลังจากจัดส่งของ ก" และ "รับสินค้า ค เกิดขึ้นหลังรับสินค้า ข"

นอกจากนี้ ลำดับความสำคัญจะยังคงมีผลเฉพาะเมื่อดำเนินการจัดส่งทั้ง 2 รายการแล้วและจะไม่มีผล

การแสดง JSON 
{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}
ช่อง
firstIsDelivery

boolean

ระบุว่าเหตุการณ์ "แรก" เป็นการนําส่งหรือไม่
secondIsDelivery

boolean

ระบุว่าเหตุการณ์ "ที่ 2" เป็นการแสดงโฆษณาหรือไม่
offsetDuration

string (Duration format)

ส่วนต่างระหว่างเหตุการณ์ "แรก" กับ "ที่ 2" อาจเป็นค่าลบก็ได้

ระยะเวลาเป็นวินาทีโดยมีเลขเศษส่วนไม่เกิน 9 หลัก ลงท้ายด้วย "s" เช่น "3.5s"
firstIndex

integer

ดัชนีการจัดส่งของเหตุการณ์ "แรก" ต้องระบุฟิลด์นี้
secondIndex

integer

ดัชนีการจัดส่งของเหตุการณ์ "ที่ 2" ต้องระบุข้อมูลในช่องนี้