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)

זמני התחלה וסיום גלובליים של המודל: שעות מחוץ לטווח הזה לא יכולות להיחשב כחוקיות.

טווח הזמן של המודל חייב להיות קצר משנה. כלומר, הטווח של globalEndTime ושל globalStartTime חייב להיות בטווח של 31536,000 שניות בין שני הערכים.

כשמשתמשים בשדות cost_per_*hour, כדאי להגדיר את החלון הזה למרווח זמן קטן יותר כדי לשפר את הביצועים (למשל, אם יוצרים מודל של יום אחד, צריך להגדיר את מגבלות הזמן הגלובליות לאותו יום). אם המדיניות לא מוגדרת, המערכת תשתמש כברירת מחדל בשעה 00:00:00 UTC , 1 בינואר 1970 (כלומר שניות: 0, יחידות ננו: 0).

חותמת זמן ב-RFC3339 UTC 'Zulu' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
globalEndTime

string (Timestamp format)

אם המדיניות לא מוגדרת, ייעשה שימוש ב-00:00:00 UTC , 1 בינואר 1971 (כלומר שניות: 31536000, ננו: 0) כברירת מחדל.

חותמת זמן ב-RFC3339 UTC 'Zulu' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
globalDurationCostPerHour

number

את 'משך הזמן הגלובלי' של התוכנית הכוללת הוא ההבדל בין שעת ההתחלה המוקדמת ביותר לתוקף לבין שעת הסיום האחרונה האפקטיבית של כל כלי הרכב. לדוגמה, משתמשים יכולים להקצות עלות לשעה לכמות הזו, כדי לנסות לבצע אופטימיזציה להשגת היעד המוקדם ביותר. העלות הזו חייבת להיות באותה יחידה של Shipment.penalty_cost.
durationDistanceMatrices[]

object (DurationDistanceMatrix)

מציינת את המטריצות של משך הזמן והמרחק שבהן נעשה שימוש במודל. אם השדה הזה ריק, המערכת תשתמש במרחקים גיאודזיים או במפות Google, בהתאם לערך בשדה useGeodesicDistances. אם השדה לא ריק, הערך של useGeodesicDistances לא יכול להיות True וגם durationDistanceMatrixSrcTags או durationDistanceMatrixDstTags לא יכולים להיות ריקים.

דוגמאות לשימוש:

  • יש שני מיקומים: locA ו-locB.
  • כלי רכב אחד מתחיל את המסלול במקום אחד ומסתיים במיקום הזה.
  • בקשת ביקור אחת לאיסוף במיקום 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.
  • רכב אחד מתחיל את המסלול ב-locA ומסתיים ב-locB באמצעות המטריצה 'fast'.
  • רכב אחד מתחיל את המסלול ב-locB ומסתיים ב-locB באמצעות המטריצה 'איטי'.
  • רכב אחד מתחיל את המסלול ב-locB ומסתיים ב-locB באמצעות המטריצה 'fast'.
  • בקשת ביקור אחת לאיסוף באתר 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 נתון חייב להתאים בדיוק לתג אחד בשדה הזה. לתשומת ליבכם: תג המקור, תג היעד ותג המטריצה של 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)

קבוצות של סוגי משלוח לא תואמים (מידע נוסף זמין ב-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.

אובייקט שמכיל רשימה של "key": value זוגות. לדוגמה: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
allowedVehicleIndices[]

integer

קבוצת כלי הרכב שיכולים לבצע את המשלוח הזה. אם היא ריקה, היא עשויה לפעול בכל כלי הרכב. הרכבים נכללים באינדקס שלהם ברשימה vehicles של ShipmentModel.
costsPerVehicle[]

number

מציינת את העלות שתחול כשהמשלוח נמסר על ידי כל רכב. אם צוין, הוא צריך להכיל EITHER:

  • אותו מספר רכיבים כמו costsPerVehicleIndices. costsPerVehicle[i] תואם לרכב costsPerVehicleIndices[i] של הדגם.
  • אותו מספר רכיבים שיש בכלי רכב במודל. הרכיב ה-i תואם לרכב מס' i של הדגם.

העלויות האלה חייבות להיות באותה יחידה של penaltyCost, ולא יכולות להיות מספר שלילי. אם אין עלויות כאלה, צריך להשאיר את השדה הזה ריק.
costsPerVehicleIndices[]

integer

מדדים של כלי הרכב שעליהם חל costsPerVehicle. אם השדה לא ריק, הוא צריך להכיל אותו מספר רכיבים כמו costsPerVehicle. אי אפשר לציין אינדקס רכבים יותר מפעם אחת. אם כלי רכב לא נכלל ב-costsPerVehicleIndices, העלות שלו היא אפס.
pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

מציינת את זמן המעקף המוחלט המקסימלי בהשוואה לנתיב הקצר ביותר מהאיסוף ועד למשלוח. אם מציינים את הערך הזה, הערך לא יכול להיות שלילי, והמשלוח צריך לכלול לפחות אפשרויות איסוף ומשלוח.

לדוגמה, צריך להזין את משך הזמן הקצר ביותר כדי לעבור מחלופה לאיסוף שנבחרה ישירות לחלופה שנבחרה. לאחר מכן, אם מגדירים אכיפה של pickupToDeliveryAbsoluteDetourLimit:

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

אם ציינתם מגבלות יחסיות ומגבלות מוחלטות על אותו משלוח, המערכת תשתמש במגבלה המגבילה יותר לכל צמד אפשרי של איסוף/מסירה. נכון ל-2017/10, אפשר להשתמש במעקפים רק כאשר משך הנסיעה לא תלוי בכלי רכב.

משך זמן בשניות עם עד תשע ספרות עשרוניות, שמסתיים ב-'s'. לדוגמה: "3.5s".
pickupToDeliveryTimeLimit

string (Duration format)

מציינת את משך הזמן המקסימלי מתחילת האיסוף ועד תחילת המשלוח של משלוח. אם מציינים את הערך הזה, הערך לא יכול להיות שלילי, והמשלוח צריך לכלול לפחות אפשרויות איסוף ומשלוח. האפשרויות האלה לא תלויות בחלופות שנבחרו לאיסוף ולמשלוח או במהירות הרכב. ניתן לציין זאת לצד מגבלות מקסימליות של עקיפה: הפתרון יתייחס לשני המפרטים.

משך זמן בשניות עם עד תשע ספרות עשרוניות, שמסתיים ב-'s'. לדוגמה: "3.5s".
shipmentType

string

מחרוזת שאינה ריקה שמציינת 'סוג' למשלוח הזה. אפשר להשתמש בתכונה הזו כדי להגדיר חוסר תאימות או דרישות בין shipment_types (אפשר לעיין ב-shipmentTypeIncompatibilities וב-shipmentTypeRequirements ב-ShipmentModel).

שונה מ-visitTypes שצוין בביקור יחיד: כל האיסוף/המשלוחים ששייכים לאותו משלוח חולקים את אותו shipmentType.
label

string

מציינת תווית למשלוח הזה. התווית הזו מדווחת בתשובה ב-shipmentLabel של ה-ShipmentRoute.Visit התואם.
ignore

boolean

אם הערך הוא True, אפשר לדלג על המשלוח הזה, אבל לא להחיל penaltyCost.

אם מתעלמים ממשלוח, מוצגת שגיאת אימות אם יש במודל shipmentTypeRequirements ערכים כלשהם.

מותר להתעלם ממשלוח שמבוצע בinjectedFirstSolutionRoutes או בinjectedSolutionConstraint; הפתרון מסיר את הביקורים הקשורים באיסוף או במסירה מהמסלול שמבצע את הפעולה. המערכת תתעלם גם מ-precedenceRules שמתייחסות למשלוחים שהמערכת התעלמה מהם.
penaltyCost

number

אם המשלוח לא הושלם, הקנס הזה יתווסף לעלות הכוללת של המסלולים. משלוח נחשב כבוצע אם מבקרים באחת מהחלופות שלו לאיסוף ולמשלוח. העלות עשויה לבוא לידי ביטוי באותה יחידה שמשמשת את כל השדות האחרים הקשורים לעלות במודל, והיא חייבת להיות חיובית.

חשוב: אם העונש הזה לא צוין, הוא נחשב ללא הגבלה, כלומר חובה לסיים את המשלוח.
pickupToDeliveryRelativeDetourLimit

number

מציינת את זמן המעקף היחסי המקסימלי בהשוואה לנתיב הקצר ביותר מהאיסוף ועד למשלוח. אם מציינים את הערך הזה, הערך לא יכול להיות שלילי, והמשלוח צריך לכלול לפחות אפשרויות איסוף ומשלוח.

לדוגמה, צריך להזין את משך הזמן הקצר ביותר כדי לעבור מחלופה לאיסוף שנבחרה ישירות לחלופה שנבחרה. לאחר מכן, אם מגדירים אכיפה של 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
}
שדות
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.

אובייקט שמכיל רשימה של "key": value זוגות. לדוגמה: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
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].

נקודת ציון

כולל ציון דרך. נקודות ציון מציינות את מיקומי ההגעה והיציאה של VisitRequests, ואת מיקומי ההתחלה והסיום של כלי הרכב.

ייצוג 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` <= `softStartTime` <= `endTime` and
  0 <= `startTime` <= `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' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
endTime

string (Timestamp format)

שעת הסיום של החלון הקופץ. אם לא צוין אחרת, הערך יוגדר ל-ShipmentModel.global_end_time.

חותמת זמן ב-RFC3339 UTC 'Zulu' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
softStartTime

string (Timestamp format)

שעת ההתחלה הרכה של חלון הזמן.

חותמת זמן ב-RFC3339 UTC 'Zulu' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
softEndTime

string (Timestamp format)

שעת הסיום הרכה של חלון הזמן.

חותמת זמן ב-RFC3339 UTC 'Zulu' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "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),
  "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.
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. אם מפתח מסוים לא מופיע במפה הזו, הקיבולת המתאימה נחשבת לא מוגבלת.

אובייקט שמכיל רשימה של "key": value זוגות. לדוגמה: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
costPerHour

number

עלויות הרכב: כל העלויות מצטברות וחייבות להיות באותה יחידה של Shipment.penalty_cost.

עלות לשעה של מסלול הרכב. העלות הזו חלה על הזמן הכולל במסלול, והיא כוללת את זמן הנסיעה, זמן ההמתנה וזמן הביקור. שימוש ב-costPerHour במקום ב-costPerTraveledHour בלבד עלול להאריך את זמן האחזור.
costPerTraveledHour

number

עלות לשעה של נסיעה במסלול הרכב. העלות הזו חלה רק על זמן הנסיעה במסלול (כלומר, שדווח ב-ShipmentRoute.transitions), ולא כוללת את זמן ההמתנה ואת זמן הביקור.
costPerKilometer

number

עלות לקילומטר של מסלול הרכב. העלות הזו חלה על המרחק שדווח בShipmentRoute.transitions והיא אינה חלה על מרחקים שנעשים במרומז מarrivalLocation אל departureLocation של VisitRequest בודד.
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 ועד לפרקי הזמן. משך הזמן הוא זמן בנוסף ל-VisitRequest.duration שיילקח בביקורים עם visitTypes שצוין. משך הביקור הנוסף הזה מוסיף עלות אם מציינים costPerHour. מפתחות (כמו visitTypes) לא יכולים להיות מחרוזות ריקות.

אם לבקשת ביקור יש מספר סוגים, משך זמן יתווסף לכל סוג במפה.

אובייקט שמכיל רשימה של "key": value זוגות. לדוגמה: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
breakRule

object (BreakRule)

מיועד לתיאור לוח הזמנים של ההפסקות לאכיפה ברכב הזה. אם השדה ריק, לא ייקבעו הפסקות לרכב הזה.
label

string

מציינת תווית לרכב הזה. התווית הזו מדווחת בתשובה כ-vehicleLabel של ה-ShipmentRoute התואם.
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

מצבי נסיעה לשימוש בכלי רכב.

הקבוצות האלה צריכות להיות קבוצת משנה של מצבי הנסיעה המועדפים ב-API של המסלולים בפלטפורמה של מפות Google, מידע נוסף זמין בכתובת: https://developers.google.com/maps/documentation/routes_preferred/reference/rest/Shared.Types/RouteTravelMode.

טיפוסים בני מנייה (enum)
TRAVEL_MODE_UNSPECIFIED מצב נסיעה לא מוגדר, המקביל ל-DRIVING.
DRIVING מצב נסיעה התואם למסלול הנסיעה (מכונית, ...).
WALKING מצב נסיעה שתואם למסלול הליכה.

UnloadingPolicy

מדיניות לגבי האופן שבו ניתן להוריד כלי רכב. המאפיין חל רק על משלוחים שכוללים גם איסוף עצמי וגם משלוח.

משלוחים אחרים מתבצעים בחינם בכל מקום במסלול, ללא קשר ל-unloadingPolicy.

טיפוסים בני מנייה (enum)
UNLOADING_POLICY_UNSPECIFIED מדיניות הסרת הנתונים שנטענו לא צוינה. והמשלוחים צריכים להתרחש רק אחרי האיסוף.
LAST_IN_FIRST_OUT משלוחים צריכים להתרחש בסדר הפוך.
FIRST_IN_FIRST_OUT המשלוחים צריכים להיות באותה הזמנה כמו באיסוף עצמי

LoadLimit

הגדרת מגבלת עומס שחלה על כלי רכב, לדוגמה "משאית כזו יכולה לשאת עד 3500 ק"ג". loadLimits.

ייצוג JSON 
{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string
}
שדות
softMaxLoad

string (int64 format)

מגבלת עומס רכה. costPerUnitAboveSoftMax.
costPerUnitAboveSoftMax

number

אם העומס בכל זאת יחרוג מ-softMaxLoad במסלול של הרכב הזה, יחול קנס העלות הבא (פעם אחת בלבד לכל רכב): (עומס - softMaxLoad) * costPerUnitAboveSoftMax. כל העלויות מצטברות וחייבות להיות באותה יחידה של Shipment.penalty_cost.
startLoadInterval

object (Interval)

מרווח העומס הקביל של הרכב בתחילת המסלול.
endLoadInterval

object (Interval)

מרווח העומס הקביל של הרכב בסוף המסלול.
maxLoad

string (int64 format)

כמות הטעינה המקסימלית הקבילה.

מרווח

מרווח של סכומי עומסים מקובלים.

ייצוג JSON 
{
  "min": string,
  "max": string
}
שדות
min

string (int64 format)

עומס קביל מינימלי. מספר זה חייב להיות 0 ומעלה. אם מציינים את שניהם, הערך של min חייב להיות ≤ max.
max

string (int64 format)

טעינה קבילה מקסימלית. מספר זה חייב להיות 0 ומעלה. אם לא צוין, ההודעה הזו לא תוכל להגביל את הטעינה המקסימלית. אם מציינים את שניהם, הערך של min חייב להיות ≤ max.

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 חייב להיות לא שלילי. אם מוגדר גם משך זמן מקסימלי, 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

מגבלה שמגדירה מרחק מקסימלי שאפשר לעבור בו. היא יכולה להיות קשה או רכה.

אם מוגדרת מגבלת softmax, צריך להגדיר גם את softMaxMeters וגם את costPerKilometerAboveSoftMax וגם לא להיות שליליים.

ייצוג JSON 
{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerAboveSoftMax": number
}
שדות
maxMeters

string (int64 format)

מגבלה קשיחה שמגבילה את המרחק ל-maxMeters לכל היותר. המגבלה חייבת להיות לא שלילית.
softMaxMeters

string (int64 format)

מגבלה רכה שלא אוכפת מגבלת מרחק מקסימלית, אבל מופרת אותה, תוביל לעלות שנוספת לעלויות אחרות שמוגדרות במודל, עם אותה יחידה.

אם מוגדרים softMaxMeters, הם חייבים להיות קטנים מ-maxMeters ולא יכולים להיות שליליים.
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. כולם צריכים לעמוד בדרישות של הBreakRequest בBreakRule הזה. פרטים נוספים זמינים בFrequencyConstraint.

BreakRequest

צריך לדעת מראש את רצף ההפסקות (כלומר, המספר והסדר שלהן) שחלים על כל רכב. ערכי ה-BreakRequest החוזרים מגדירים את הרצף הזה, בסדר שבו הם חייבים להתרחש. חלונות הזמן שלהם (earliestStartTime / latestStartTime) עשויים להיות חופפים, אבל הם צריכים להיות תואמים להזמנה (האפשרות הזו מסומנת).

ייצוג JSON 
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
שדות
earliestStartTime

string (Timestamp format)

חובה. הגבול התחתון (כולל) בתחילת ההפסקה.

חותמת זמן ב-RFC3339 UTC 'Zulu' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
latestStartTime

string (Timestamp format)

חובה. גבול עליון (כולל) בתחילת ההפסקה.

חותמת זמן ב-RFC3339 UTC 'Zulu' בפורמט של רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
minDuration

string (Duration format)

חובה. משך זמן מינימלי להפסקה. חייב להיות חיובי.

משך זמן בשניות עם עד תשע ספרות עשרוניות, שמסתיים ב-'s'. לדוגמה: "3.5s".

FrequencyConstraint

אפשר להגביל עוד יותר את התדירות ואת משך ההפסקות שצוינו למעלה, על ידי אכיפה של תדירות מינימלית של הפסקות, למשל "חייבת להיות הפסקה של שעה לפחות בכל 12 שעות". בהנחה שאפשר לפרש את זה בתור "בכל חלון זמן הזזה של 12 שעות, חייבת להיות לפחות הפסקה אחת של שעה אחת לפחות", הדוגמה הבאה תתורגם לFrequencyConstraint הבאה:

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

התזמון ומשך הזמן של ההפסקות בפתרון יחולו על כל המגבלות האלה, בנוסף לחלונות הזמן ולמשכי הזמן המינימליים שצוינו ב-BreakRequest.

בפועל, FrequencyConstraint יכול לחול על הפסקות לא ברצף. לדוגמה, לוח הזמנים הבא חל על השעה 12:00 דוגמה:

  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".

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.

משך זמן בשניות עם עד תשע ספרות עשרוניות, שמסתיים ב-'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/06, אפשר להשתמש רק במגבלות רכות.
delay

string (Duration format)

מציינת עיכוב שחל במהלך ביצוע המעבר.

העיכוב הזה מתרחש תמיד אחרי סיום הביקור במקור ולפני ההתחלה של הביקור ביעד.

משך זמן בשניות עם עד תשע ספרות עשרוניות, שמסתיים ב-'s'. לדוגמה: "3.5s".

ShipmentTypeIncompatibility

מציינת חוסר תאימות בין משלוחים בהתאם לסוג המשלוח שלהם. ההצגה של משלוחים לא תואמים באותו מסלול מוגבלת בהתאם למצב חוסר התאימות.

ייצוג JSON 
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
שדות
types[]

string

רשימת סוגים לא תואמים. שני משלוחים עם shipment_types שונים מאלה שצוינו "לא תואמים".
incompatibilityMode

enum (IncompatibilityMode)

המצב הוחל על חוסר התאימות.

IncompatibilityMode

מצבים שמגדירים את האופן שבו משלוחים לא תואמים מוגבלים לאותו מסלול.

טיפוסים בני מנייה (enum)
INCOMPATIBILITY_MODE_UNSPECIFIED מצב חוסר תאימות לא צוין. אין להשתמש בערך הזה אף פעם.
NOT_PERFORMED_BY_SAME_VEHICLE במצב הזה, שני משלוחים עם סוגים לא תואמים אף פעם לא יכולים לחלוק את אותו רכב.
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

לשני משלוחים שאינם תואמים למצב חוסר התאימות של NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY:

  • אם שתיהן הן איסוף עצמי (ללא משלוחים) או משלוחים בלבד (ללא איסוף), לא ניתן להשתמש באותו רכב בכלל.
  • אם אחד מהמשלוחים כולל משלוח והשני איסוף, שני המשלוחים יכולים לחלוק את אותו רכב אם המשלוח הקודם נמסר לפני איסוף המשלוח.

ShipmentTypeRequirement

מציינת את הדרישות בין משלוחים על סמך סוג המשלוח שלהם. הפרטים הספציפיים של הדרישה מוגדרים על ידי מצב הדרישה.

ייצוג JSON 
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
שדות
requiredShipmentTypeAlternatives[]

string

רשימה של סוגי משלוח חלופיים שנדרשים על ידי dependentShipmentTypes.
dependentShipmentTypes[]

string

לכל משלוחים מסוג מסוים בשדה dependentShipmentTypes נדרש לפחות משלוח אחד מסוג requiredShipmentTypeAlternatives באותו מסלול.

הערה: אסור להשתמש בשרשראות של דרישות כמו shipmentType שתלויות בעצמו.
requirementMode

enum (RequirementMode)

המצב הוחל על הדרישה.

RequirementMode

מצבים שמגדירים את המראה של משלוחים תלויים במסלול.

טיפוסים בני מנייה (enum)
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 לפחות אחרי 'first' התחיל.

כמה קדימות יכולות להתייחס לאותם אירועים (או אירועים קשורים). למשל: "איסוף ב' מתבצע אחרי המסירה של" ו'איסוף 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

אינדקס המשלוח של ה'שנייה' אירוע. צריך לציין את השדה הזה.