ShipmentModel

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

  • העלות של ניתוב כלי הרכב (סכום של העלות לכל משך זמן, העלות לכל זמן נסיעה והעלות הקבועה בכל כלי הרכב).
  • את הקנסות על משלוחים שלא בוצעו.
  • העלות של משך הזמן הכולל של המשלוחים
ייצוג ב-JSON 
{
  "shipments": [
    {
      object (Shipment)
    }
  ],
  "vehicles": [
    {
      object (Vehicle)
    }
  ],
  "objectives": [
    {
      object (Objective)
    }
  ],
  "globalStartTime": string,
  "globalEndTime": string,
  "globalDurationCostPerHour": number,
  "durationDistanceMatrices": [
    {
      object (DurationDistanceMatrix)
    }
  ],
  "durationDistanceMatrixSrcTags": [
    string
  ],
  "durationDistanceMatrixDstTags": [
    string
  ],
  "transitionAttributes": [
    {
      object (TransitionAttributes)
    }
  ],
  "shipmentTypeIncompatibilities": [
    {
      object (ShipmentTypeIncompatibility)
    }
  ],
  "shipmentTypeRequirements": [
    {
      object (ShipmentTypeRequirement)
    }
  ],
  "precedenceRules": [
    {
      object (PrecedenceRule)
    }
  ],
  "maxActiveVehicles": integer
}
שדות
shipments[]

object (Shipment)

קבוצת משלוחים שצריך לבצע במודל.
vehicles[]

object (Vehicle)

קבוצה של כלי רכב שאפשר להשתמש בהם לביצוע ביקורים.
objectives[]

object (Objective)

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

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.
globalStartTime

string (Timestamp format)

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

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

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

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
globalEndTime

string (Timestamp format)

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

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
globalDurationCostPerHour

number

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

object (DurationDistanceMatrix)

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

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

  • יש שני מיקומים: locA ו-locB.
  • כלי רכב אחד שמתחיל את המסלול ב-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.
allowedVehicleIndices[]

integer

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

number

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

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

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

integer

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

string (Duration format)

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

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

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

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

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

VisitRequest

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

ייצוג ב-JSON 
{
  "arrivalLocation": {
    object (LatLng)
  },
  "arrivalWaypoint": {
    object (Waypoint)
  },
  "departureLocation": {
    object (LatLng)
  },
  "departureWaypoint": {
    object (Waypoint)
  },
  "tags": [
    string
  ],
  "timeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "duration": string,
  "cost": number,
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "visitTypes": [
    string
  ],
  "label": string,
  "avoidUTurns": boolean
}
שדות
arrivalLocation

object (LatLng)

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

object (Waypoint)

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

object (LatLng)

המיקום הגיאוגרפי שבו הרכב יוצא לאחר השלמת הVisitRequest הזה. אפשר להשמיט אותו אם הוא זהה ל-arrivalLocation. אם למודל המשלוח יש מטריצות של משך זמן ומרחק, אסור לציין את departureLocation.
departureWaypoint

object (Waypoint)

נקודת הציון שממנה הרכב יוצא אחרי השלמת VisitRequest הזה. אפשר להשמיט אותו אם הוא זהה ל-arrivalWaypoint. אם למודל המשלוח יש מטריצות של משך זמן ומרחק, אסור לציין את departureWaypoint.
tags[]

string

מציין את התגים שמצורפים לבקשת הביקור. אסור להשתמש במחרוזות ריקות או כפולות.
timeWindows[]

object (TimeWindow)

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

אם השדה TimeWindow לא מופיע, המשמעות היא שהרכב יכול לבצע את הביקור הזה בכל שלב.

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

אפשר להגדיר את costPerHourAfterSoftEndTime ו-softEndTime רק אם יש חלון זמן אחד.
duration

string (Duration format)

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

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

number

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

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

דרישות העומס של בקשת הביקור הזו. השדה הזה דומה לשדה Shipment.load_demands, אבל הוא חל רק על VisitRequest הזה במקום על כל Shipment. הדרישות שמפורטות כאן מתווספות לדרישות שמפורטות בקובץ Shipment.load_demands.
visitTypes[]

string

מציין את סוגי הביקורים. אפשר להשתמש בזמן הזה כדי להקצות זמן נוסף שנדרש לרכב כדי להשלים את הביקור הזה (ראו Vehicle.extra_visit_duration_for_visit_type).

סוג יכול להופיע רק פעם אחת.
label

string

תווית של VisitRequest. התווית הזו מדווחת בתגובה כ-visitLabel ב-ShipmentRoute.Visit התואם.
avoidUTurns

boolean

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

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request.

LatLng

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

ייצוג ב-JSON 
{
  "latitude": number,
  "longitude": number
}
שדות
latitude

number

קו הרוחב במעלות. הוא חייב להיות בטווח [-90.0, +90.0].
longitude

number

קו האורך במעלות. הוא חייב להיות בטווח [-180.0, +180.0].

נקודת ציון

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

ייצוג ב-JSON 
{
  "sideOfRoad": boolean,
  "vehicleStopover": 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

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

boolean

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

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

object (Location)

נקודה שצוינה באמצעות קואורדינטות גיאוגרפיות, כולל כותרת אופציונלית.
placeId

string

מזהה המקום של נקודת העניין שמשויך לנקודת הציון.

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

מיקום

עטיפה של מיקום (נקודה גיאוגרפית וכותרת אופציונלית).

ייצוג ב-JSON 
{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}
שדות
latLng

object (LatLng)

הקואורדינטות הגיאוגרפיות של נקודת הציון.
heading

integer

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

TimeWindow

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

גבולות קשיחים של חלון הזמן, startTime ו-endTime, אוכפים את השעה המוקדמת ביותר ואת השעה המאוחרת ביותר של האירוע, כך ש-startTime <= event_time <= endTime. הערך התחתון של חלון הזמן הרך, softStartTime, מבטא העדפה שהאירוע יתרחש ב-softStartTime או אחריו, על ידי צבירת עלות שפרופורציונלית לזמן שחולף לפני softStartTime שבו מתרחש האירוע. הגבול העליון של חלון הזמן הרך, softEndTime, מבטא העדפה שהאירוע יתרחש ב-softEndTime או לפני כן, על ידי חיוב בעלות שפרופורציונלית למשך הזמן שחולף אחרי softEndTime עד שהאירוע מתרחש. הערכים של startTime, ‏ endTime, ‏ softStartTime ו-softEndTime צריכים לעמוד במגבלות הזמן הגלובליות (ראו ShipmentModel.global_start_time ו-ShipmentModel.global_end_time) ולעמוד בדרישות הבאות:

  0 <= `startTime` <= `endTime` and
  0 <= `startTime` <= `softStartTime` and
  0 <= `softEndTime` <= `endTime`.
ייצוג ב-JSON 
{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}
שדות
startTime

string (Timestamp format)

שעת ההתחלה של חלון הזמן הקבוע. אם לא יצוין ערך, הוא יוגדר כ-ShipmentModel.global_start_time.

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
endTime

string (Timestamp format)

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

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
softStartTime

string (Timestamp format)

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

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
softEndTime

string (Timestamp format)

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

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
costPerHourBeforeSoftStartTime

number

עלות לשעה שנוספת לעלויות אחרות במודל אם האירוע מתרחש לפני softStartTime, מחושבת לפי הנוסחה הבאה:

   max(0, softStartTime - t.seconds)
                          * costPerHourBeforeSoftStartTime / 3600,
t being the time of the event.

העלות הזו חייבת להיות חיובית, וניתן להגדיר את השדה רק אם softStartTime הוגדר.
costPerHourAfterSoftEndTime

number

עלות לשעה שנוספת לעלויות אחרות במודל אם האירוע מתרחש אחרי softEndTime, מחושבת לפי הנוסחה הבאה:

   max(0, t.seconds - softEndTime.seconds)
                    * costPerHourAfterSoftEndTime / 3600,
t being the time of the event.

העלות הזו חייבת להיות חיובית, וניתן להגדיר את השדה רק אם softEndTime הוגדר.

כלי רכב

מודל של רכב בבעיה במשלוח. פתרון בעיה בשליחה יוצר מסלול לרכב הזה שמתחיל ב-startLocation ומסתיים ב-endLocation. מסלול הוא רצף של ביקורים (ראו ShipmentRoute).

ייצוג ב-JSON 
{
  "displayName": string,
  "travelMode": enum (TravelMode),
  "routeModifiers": {
    object (RouteModifiers)
  },
  "startLocation": {
    object (LatLng)
  },
  "startWaypoint": {
    object (Waypoint)
  },
  "endLocation": {
    object (LatLng)
  },
  "endWaypoint": {
    object (Waypoint)
  },
  "startTags": [
    string
  ],
  "endTags": [
    string
  ],
  "startTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "endTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "unloadingPolicy": enum (UnloadingPolicy),
  "loadLimits": {
    string: {
      object (LoadLimit)
    },
    ...
  },
  "costPerHour": number,
  "costPerTraveledHour": number,
  "costPerKilometer": number,
  "fixedCost": number,
  "usedIfRouteIsEmpty": boolean,
  "routeDurationLimit": {
    object (DurationLimit)
  },
  "travelDurationLimit": {
    object (DurationLimit)
  },
  "routeDistanceLimit": {
    object (DistanceLimit)
  },
  "extraVisitDurationForVisitType": {
    string: string,
    ...
  },
  "breakRule": {
    object (BreakRule)
  },
  "label": string,
  "ignore": boolean,
  "travelDurationMultiple": number
}
שדות
displayName

string

השם המוצג של הרכב שהוגדר על ידי המשתמש. הוא יכול להכיל עד 63 תווים, וניתן להשתמש בו בתווים בתקן UTF-8.
travelMode

enum (TravelMode)

אופן הנסיעה שמשפיע על הכבישים שבהם הרכב יכול לנסוע ועל המהירות שלו. למידע נוסף, אפשר לעיין במאמר travelDurationMultiple.
routeModifiers

object (RouteModifiers)

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

object (LatLng)

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

object (Waypoint)

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

object (LatLng)

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

object (Waypoint)

נקודת ציון שמייצגת מיקום גיאוגרפי שבו הרכב מסתיים אחרי שהוא משלים את VisitRequest האחרון שלו. אם לא מציינים את endWaypoint או את endLocation, ShipmentRoute של הרכב מסתיים מיד אחרי השלמת VisitRequest האחרון. אם למודל המשלוח יש מטריצות של משך זמן ומרחק, אסור לציין את endWaypoint.
startTags[]

string

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

אסור להשתמש במחרוזות ריקות או כפולות.
endTags[]

string

ציון תגים שמצורפים לסוף המסלול של הרכב.

אסור להשתמש במחרוזות ריקות או כפולות.
startTimeWindows[]

object (TimeWindow)

חלונות זמן שבהם הרכב עשוי לצאת ממיקום ההתחלה. הם צריכים להיות בתוך מגבלות הזמן הגלובליות (ראו שדות ShipmentModel.global_*). אם לא צוין אחרת, אין הגבלה מלבד מגבלות הזמן הגלובליות האלה.

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

אפשר להגדיר את costPerHourAfterSoftEndTime ו-softEndTime רק אם יש חלון זמן אחד.
endTimeWindows[]

object (TimeWindow)

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

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

אפשר להגדיר את costPerHourAfterSoftEndTime ו-softEndTime רק אם יש חלון זמן אחד.
unloadingPolicy

enum (UnloadingPolicy)

מדיניות פריקה שחלה על הרכב.
loadLimits

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

הקיבולת של הרכב (משקל, נפח, מספר פלטפורמות, לדוגמה). המפתחות במפה הם המזהים של סוג העומס, בהתאם למפתחות של השדה Shipment.load_demands. אם מפתח מסוים חסר במפה הזו, הקיבולת התואמת נחשבת כבלתי מוגבלת.
costPerHour

number

עלויות רכב: כל העלויות צריכות להתווסף זו לזו, והן חייבות להיות באותה יחידה כמו Shipment.penalty_cost.

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

number

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

number

העלות לקילומטר במסלול הרכב. העלות הזו חלה על המרחק שמדווח ב-ShipmentRoute.transitions, ולא חלה על כל מרחק שעבר באופן משתמע מ-arrivalLocation ל-departureLocation של VisitRequest יחיד.
fixedCost

number

עלות קבועה שחלה אם הרכב הזה משמש לטיפול במשלוח.
usedIfRouteIsEmpty

boolean

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

אם הערך הוא 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) לא יכולים להיות מחרוזות ריקות.

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

אמצעי הגעה שאפשר להשתמש בהם ברכב.

אלה צריכים להיות קבוצת משנה של שיטות הנסיעה של Routes API בפלטפורמה של מפות Google. אפשר לקרוא על כך במאמר: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode

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

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

RouteModifiers

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

ייצוג ב-JSON 
{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}
שדות
avoidTolls

boolean

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

boolean

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

boolean

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

boolean

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

UnloadingPolicy

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

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

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

LoadLimit

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

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

string (int64 format)

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

number

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

object (Interval)

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

object (Interval)

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

string (int64 format)

עומס מקסימלי מקובל.
costPerKilometer

object (LoadCost)

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

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.
costPerTraveledHour

object (LoadCost)

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

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

מרווח

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

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

string (int64 format)

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

string (int64 format)

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

LoadCost

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

  • min(load, loadThreshold) * costPerUnitBelowThreshold
  • max(0, load - loadThreshold) * costPerUnitAboveThreshold

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

load_limit {
  key: "weight"
  value {
    costPerKilometer {
      loadThreshold: 15
      costPerUnitBelowThreshold: 2.0
      costPerUnitAboveThreshold: 10.0
    }
  }
}

והמסלול שלו הוא start,pickup,pickup,delivery,delivery,end עם מעברים:

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 20 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

במקרה כזה, העלות שנצברה ב-LoadCost היא (cost_below * load_below * kilometers + cost_above * load_above * kms)

  • transition 0: 0.0
  • מעבר 1: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 2: 2.0 * 15 * 1.0 + 10.0 * (20 - 15) * 1.0 = 80.0
  • מעבר 3: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 4: 0.0

לכן הערך של LoadCost במסלול הוא 120.0.

עם זאת, אם הנתיב הוא 'התחלה', 'איסוף', 'מסירה', 'איסוף', 'מסירה', 'סיום' עם מעברים:

transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travelDistanceMeters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travelDistanceMeters: 1000.0 }

העלות שנצברה ב-LoadCost היא

  • transition 0: 0.0
  • מעבר 1: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 2: 0.0
  • מעבר 3: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • מעבר 4: 0.0

כאן הערך של LoadCost במסלול הוא 40.0.

LoadCost הופכת פתרונות עם מעברים עמוסים יותר ליקרים יותר.

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

ייצוג ב-JSON 
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
שדות
loadThreshold

string (int64 format)

כמות העומס שמעליה העלות להעברת יחידת עומס משתנה מ-costPerUnitBelowThreshold ל-costPerUnitAboveThreshold. הערך חייב להיות גדול מ-0.
costPerUnitBelowThreshold

number

העלות להעברת יחידת עומס, לכל יחידה בין 0 לסף. הערך חייב להיות סופי וגדול מ-0.
costPerUnitAboveThreshold

number

העלות של העברת יחידת עומס, לכל יחידה מעל הסף. במקרה המיוחד שבו הסף = 0, מדובר בעלות קבועה לכל יחידה. הערך חייב להיות סופי וגדול מ-0.

DurationLimit

מגבלה שמגדירה את משך הזמן המקסימלי של מסלול הרכב. הוא יכול להיות קשה או רך.

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

ייצוג ב-JSON 
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
שדות
maxDuration

string (Duration format)

מגבלה קשיחה שמגבילה את משך הזמן ל-maxDuration לכל היותר.

משך הזמן בשניות, עם עד תשע ספרות עשרוניות, שמסתיימים ב-'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,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}
שדות
maxMeters

string (int64 format)

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

string (int64 format)

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

אם softMaxMeters מוגדר, הערך שלו חייב להיות קטן מ-maxMeters ולא שלילי.
costPerKilometerBelowSoftMax

number

העלות לקילומטר שנצברה, ועולה עד softMaxMeters, לפי הנוסחה:

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

העלות הזו לא נתמכת ב-routeDistanceLimit.
costPerKilometerAboveSoftMax

number

העלות לקילומטר תחויב אם המרחק חורג מהמגבלה softMaxMeters. העלות הנוספת היא 0 אם המרחק נמוך מהמגבלה, אחרת הנוסחה לחישוב העלות היא:

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

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

BreakRule

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

  • במהלך הנסיעה בין שני ביקורים (כולל הזמן שלפני הביקור או אחריו, אבל לא באמצע הביקור). במקרה כזה, זמן הנסיעה המתאים בין הביקורים יתארך.
  • או לפני הפעלת הרכב (לא ניתן להפעיל את הרכב באמצע הפסקה), במקרה כזה הוא לא משפיע על מועד הפעלת הרכב.
  • או אחרי סיום הנסיעה ברכב (אותו הדבר, עם זמן סיום הנסיעה ברכב).
ייצוג ב-JSON 
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
שדות
breakRequests[]

object (BreakRequest)

רצף ההפסקות. הצגת ההודעה BreakRequest.
frequencyConstraints[]

object (FrequencyConstraint)

יכול להיות שיחולו כמה FrequencyConstraint. כל התנאים האלה חייבים להתקיים לגבי ה-BreakRequest של ה-BreakRule הזה. ראו FrequencyConstraint.

BreakRequest

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

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

string (Timestamp format)

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

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
latestStartTime

string (Timestamp format)

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

הפורמט הזה משתמש ב-RFC 3339, שבו הפלט שנוצר תמיד יהיה מנורמלי לפי Z וישמש בספרות עשרוניות של 0, 3, 6 או 9. אפשר להשתמש גם בשינויים (offsets) אחרים מלבד 'Z'. דוגמאות: "2014-10-02T15:01:23Z", ‏ "2014-10-02T15:01:23.045123456Z" או "2014-10-02T15:01:23+05:30".
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".

מטרה

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

ניסיוני: פרטים נוספים זמינים בכתובת https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.

ייצוג ב-JSON 
{
  "type": enum (Type),
  "weight": number
}
שדות
type

enum (Type)

סוג היעד.
weight

number

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

סוג

סוג היעד שיתואם לקבוצת עלויות.

טיפוסים בני מנייה (enum)
DEFAULT כדי להבטיח פתרון סביר, המערכת תשתמש בקבוצת עלויות שמוגדרת כברירת מחדל. הערה: אפשר להשתמש ביעד הזה בפני עצמו, אבל הוא תמיד יתווסף עם משקל 1.0, כבסיס, ליעדים שצוינו על ידי המשתמש, אם הוא עדיין לא קיים.
MIN_DISTANCE יעדי 'MIN'. צמצום מרחק הנסיעה הכולל.
MIN_WORKING_TIME צמצום משך העבודה הכולל, בסיכום של כל כלי הרכב.
MIN_TRAVEL_TIME כנ"ל, אבל התמקדות בזמן הנסיעה בלבד.
MIN_NUM_VEHICLES צמצום מספר כלי הרכב שבהם נעשה שימוש.

DurationDistanceMatrix

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

ייצוג ב-JSON 
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
שדות
rows[]

object (Row)

מציין את השורות של מטריצות משך הזמן והמרחק. הוא חייב להכיל את אותו מספר רכיבים כמו ShipmentModel.duration_distance_matrix_src_tags.
vehicleStartTag

string

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

כל התחלה של כלי רכב חייבת להתאים למטריצה אחת בלבד, כלומר, אחד מהשדות startTags שלהם חייב להתאים ל-vehicleStartTag של מטריצה (ולמטריצה הזו בלבד).

לכל המטריצות צריך להיות vehicleStartTag שונה.

שורה

מציין שורה במטריצה של משך הזמן והמרחק.

ייצוג ב-JSON 
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
שדות
durations[]

string (Duration format)

ערכי משך הזמן בשורה נתונה. הוא חייב להכיל את אותו מספר רכיבים כמו ShipmentModel.duration_distance_matrix_dst_tags.

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

number

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

TransitionAttributes

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

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

מציין אי-תאימות בין משלוחים בהתאם ל-shipmentType שלהם. הצגת משלוחים לא תואמים באותו מסלול מוגבלת על סמך מצב אי-התאימות.

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

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

ייצוג ב-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 אחרי שהאירוע 'ראשון' התחיל.

כמה סדרי עדיפויות יכולים להתייחס לאותו אירוע (או לאירועים קשורים), למשל: "האיסוף של B מתרחש אחרי המסירה של A" וגם "האיסוף של 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

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