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

חותמת זמן בפורמט 'Zulu' בפורמט 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) כברירת מחדל.

חותמת זמן בפורמט UTC 'Zulu' של RFC3339, עם רזולוציה של ננו-שנייה ועד תשע ספרות עשרוניות. דוגמאות: "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 באמצעות המטריצה 'איטי'.
  • רכב אחד שמתחיל את המסלול ב-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) (resp durationDistanceMatrices(i).rows(j).meters(k)) מגדיר את משך הנסיעה (או המרחק) מביקורים עם התג durationDistanceMatrixSrcTags(j) לביקורים עם התג durationDistanceMatrixDstTags(k) במטריצה i.

התגים תואמים ל-VisitRequest.tags או ל-Vehicle.start_tags. VisitRequest או Vehicle נתון חייב להתאים בדיוק לתג אחד בשדה הזה. לתשומת ליבכם: תג המקור, תג היעד ותג המטריצה של Vehicle עשויים להיות זהים. באופן דומה, תגי המקור ותג היעד של VisitRequest עשויים להיות זהים. כל התגים צריכים להיות שונים ולא להיות מחרוזות ריקות. אם השדה הזה לא ריק, השדה durationDistanceMatrices לא יכול להיות ריק.
transitionAttributes[]

object (TransitionAttributes)

מאפייני מעבר שנוספו למודל.
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

קבוצות של shipment_types לא תואמים (ראו ShipmentTypeIncompatibility).
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

מערכי של דרישות shipmentType (ראו ShipmentTypeRequirement).
precedenceRules[]

object (PrecedenceRule)

קבוצת כללי עדיפות שצריך לאכוף במודל.
maxActiveVehicles

integer

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

משלוח

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

ייצוג ב-JSON 
{
  "displayName": string,
  "pickups": [
    {
      object (VisitRequest)
    }
  ],
  "deliveries": [
    {
      object (VisitRequest)
    }
  ],
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "allowedVehicleIndices": [
    integer
  ],
  "costsPerVehicle": [
    number
  ],
  "costsPerVehicleIndices": [
    integer
  ],
  "pickupToDeliveryAbsoluteDetourLimit": string,
  "pickupToDeliveryTimeLimit": string,
  "shipmentType": string,
  "label": string,
  "ignore": boolean,
  "penaltyCost": number,
  "pickupToDeliveryRelativeDetourLimit": number
}
שדות
displayName

string

שם התצוגה שהמשתמש הגדיר למשלוח. הוא יכול להכיל עד 63 תווים ויכול להשתמש בתווי UTF-8.
pickups[]

object (VisitRequest)

קבוצה של חלופות לאיסוף המשוכות למשלוח. אם לא צוין מיקום, הרכב צריך להגיע רק למיקום שמתאים להעברות.
deliveries[]

object (VisitRequest)

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

map (key: string, value: object (Load))

יש לטעון את הדרישות של המשלוח (לדוגמה, משקל, נפח, מספר המשטחים וכו'). המפתחות במפה צריכים להיות מזהים שמתארים את סוג העומס המתאים, רצוי שגם יחד עם היחידות. לדוגמה: 'weight_kg', 'volume_gallons', 'pallet_count' וכו'. אם מפתח מסוים לא מופיע במפה, העומס התואם נחשב כ-null.

אובייקט שמכיל רשימה של זוגות "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)

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

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

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

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

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

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

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

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

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

VisitRequest

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

ייצוג JSON 
{
  "arrivalLocation": {
    object (LatLng)
  },
  "arrivalWaypoint": {
    object (Waypoint)
  },
  "departureLocation": {
    object (LatLng)
  },
  "departureWaypoint": {
    object (Waypoint)
  },
  "tags": [
    string
  ],
  "timeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "duration": string,
  "cost": number,
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "visitTypes": [
    string
  ],
  "label": string
}
שדות
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

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

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

string (Timestamp format)

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

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

string (Timestamp format)

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

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

string (Timestamp format)

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

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

אובייקט שמכיל רשימה של זוגות "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 מצב נסיעה שתואם למסלול הליכה.
TRUCK נסיעה במשאית. המצב הזה כרוך בהגבלות פיזיות ומשפטיות.

RouteModifiers

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

ייצוג JSON 
{
  "vehicleInfo": {
    object (VehicleInfo)
  }
}
שדות
vehicleInfo

object (VehicleInfo)

מציין את פרטי הרכב.

VehicleInfo

כולל את פרטי הרכב, כמו מידע על המשאית.

ייצוג ב-JSON 
{
  "totalAxleCount": integer,
  "totalHeightMm": string,
  "totalLengthMm": string,
  "totalWidthMm": string,
  "totalWeightKg": string,
  "trailerInfo": [
    {
      object (TrailerInfo)
    }
  ],
  "hazardousGoodsTypes": [
    enum (HazardousGoodsType)
  ]
}
שדות
totalAxleCount

integer

המספר הכולל של הצירים. הערך חייב להיות גדול מ-2. נדרשת הפעלה של משאית או נגרר. ההגדרה חלה רק על מצב הנסיעה TRUCK.
totalHeightMm

string (int64 format)

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

string (int64 format)

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

string (int64 format)

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

string (int64 format)

משקל הרכב, כולל המשקלים של כל גורר שמחובר אליו. משקל בהקשר הזה מתייחס למשקל בפועל, ולא לדירוג המשקל. צריך להגדיר את האפשרות הזו כדי שהאירוע יופעל כשמשתמשים בטרקטורים או בטריילרים. רלוונטי רק למצב הנסיעה TRUCK.
trailerInfo[]

object (TrailerInfo)

רלוונטי רק למצב הנסיעה TRUCK.
hazardousGoodsTypes[]

enum (HazardousGoodsType)

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

TrailerInfo

מידע על קרוואנים נפרדים שמחוברים לרכב. למשאיות יש לספק את האורך של כל נגרר. סך כל המאפיינים חייב לכלול את המאפיינים של טריילרים. לדוגמה, הערך של totalHeightMm תמיד חייב להיות גדול מ-trailerInfo.height_mm או שווה לו.

ייצוג JSON 
{
  "lengthMm": string
}
שדות
lengthMm

string (int64 format)

אורך הטריילר.

HazardousGoodsType

סוגים שונים של חומרים מסוכנים.

טיפוסים בני מנייה (enum)
HAZARDOUS_GOODS_TYPE_UNSPECIFIED לא ציינת סוג חומרים מסוכנים.
EXPLOSIVES חומרי נפץ.
GASES גזים.
FLAMMABLE מוצרים דליקים.
COMBUSTIBLE מוצרים דליקים.
ORGANIC מוצרים אורגניים.
POISON סחורות רעילות.
RADIOACTIVE מוצרים רדיואקטיביים.
CORROSIVE מוצרים מאכלים.
ASPIRATION_HAZARD מוצרים מסוכנים.
ENVIRONMENTAL_HAZARD סחורות מסוכנות לסביבה.
OTHER סוגים אחרים של מוצרים.

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
}
שדות
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

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

אם מוגדרת מגבלת 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)

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

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

string (Timestamp format)

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

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

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

החל מיוני 2021, יש תמיכה רק במגבלות רכות.
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 אחרי שהאירוע 'ראשון' התחיל.

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

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

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

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