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, עם רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "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, עם רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "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.
  • כלי רכב אחד שמתחיל את המסלול ב-locA ומסתיים בו ב-locA.
  • בקשת ביקור אחת לאיסוף ב-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, באמצעות המטריצה 'מהירה'.
  • כלי רכב אחד שמתחיל את המסלול ב-locB ומסתיים בספרות locB, תוך שימוש במטריצת 'slow'.
  • כלי רכב אחד שמתחיל את המסלול ב-locB ומסתיים בספרות locB, תוך שימוש במטריצת 'מהיר'.
  • בקשת ביקור אחת לאיסוף ב-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, עם רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
endTime

string (Timestamp format)

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

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

string (Timestamp format)

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

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

string (Timestamp format)

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

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

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

יש לעיין גם ב-extraVisitDurationForVisitType בהמשך.

TravelMode

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

הקבוצות האלה צריכות להיות קבוצת משנה של אמצעי התחבורה שמוגדרים כ-Preferred API Routes API. ניתן למצוא מידע בכתובת https://developers.google.com/maps/documentation/routes_preferred/reference/rest/Shared.Types/RouteTravelMode.

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

UnloadingPolicy

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

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

טיפוסים בני מנייה (enums)
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
}
שדות
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 חייב להיות מספר לא שלילי. אם הוגדר גם maxDuration, softMaxDuration חייב להיות קטן מ-maxDuration.

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

string (Duration format)

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

אם מוגדר, quadraticSoftMaxDuration חייב להיות מספר לא שלילי. אם מגדירים גם maxDuration, הערך של quadraticSoftMaxDuration חייב להיות קטן מ-maxDuration וההפרש לא יכול להיות גדול מיום אחד:

maxDuration - quadraticSoftMaxDuration <= 86400 seconds

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

number

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

  costPerHourAfterSoftMax * (duration - softMaxDuration)

העלות חייבת להיות לא שלילית.
costPerSquareHourAfterQuadraticSoftMax

number

עלות לשעה רבועה שנצברו במקרה של הפרת הסף של quadraticSoftMaxDuration.

העלות הנוספת היא 0 אם משך הזמן נמוך מהסף, אחרת העלות תלויה במשך הזמן באופן הבא:

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

העלות חייבת להיות לא שלילית.

DistanceLimit

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

אם הוגדרה מגבלת "הגבלה", גם softMaxMeters וגם costPerKilometerAboveSoftMax חייבים להיות מוגדרים ולהיות לא שליליים.

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

string (int64 format)

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

string (int64 format)

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

אם מוגדרים ערכי softMaxMeter, הערך של softMaxMeter חייב להיות לא שלילי.
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, עם רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "2014-10-02T15:01:23Z" ו-"2014-10-02T15:01:23.045123456Z".
latestStartTime

string (Timestamp format)

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

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

משך זמן בשניות עם עד תשע ספרות עשרוניות, המסתיים ב-'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)

המדיניות הזו מציינת מגבלה על המרחק שהמעבר צריך לבצע.

החל מ-6 ביוני 2021 יש תמיכה רק במגבלות רכות.
delay

string (Duration format)

מציין עיכוב במהלך ביצוע המעבר הזה.

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

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

ShipmentTypeIncompatibility

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

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

string

רשימת סוגים שאינם תואמים. שתי משלוחים עם shipment_types שונים מבין אלה שברשימה 'לא תואמים'.
incompatibilityMode

enum (IncompatibilityMode)

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

IncompatibilityMode

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

טיפוסים בני מנייה (enums)
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

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

טיפוסים בני מנייה (enums)
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 אחרי תחילת הערך "ראשון".

כמה קדימות יכולות להתייחס לאותם אירועים (או לאירועים קשורים), למשל "איסוף של פריט ב' קורה אחרי המסירה של א'" ו"איסוף של מוצר ג' קורה אחרי האיסוף של מוצר ב'.

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

ייצוג 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

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