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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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.
  • רכב אחד שמתחיל את המסלול שלו במיקום א' ומסיים אותו במיקום א'.
  • בקשת ביקור אחת לאיסוף במיקום ב'.
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.
  • כלי רכב אחד מתחיל את המסלול במיקום א' ומסיים אותו במיקום ב', באמצעות מטריצה מסוג fast.
  • רכב אחד שמתחיל את המסלול שלו במיקום 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) (בהתאמה ‫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_type לא תואמים (ראו 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

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

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

string (Duration format)

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

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

string

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

שונה מvisitTypes שמוגדר לביקור יחיד: כל האיסופים או המשלוחים ששייכים לאותו משלוח מקבלים את אותו shipmentType.
label

string

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

boolean

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

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

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

number

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

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

number

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

לדוגמה, נניח ש-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,
  "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

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

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

LatLng

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

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

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

object (Location)

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

string

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

כשמשתמשים במזהה מקום כדי לציין את מיקום ההגעה או היציאה של VisitRequest, צריך להשתמש במזהה מקום ספציפי מספיק כדי לקבוע מיקום 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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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 Maps Platform. מידע נוסף זמין בכתובת: https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode

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

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

RouteModifiers

המאפיין הזה כולל קבוצה של תנאים אופציונליים שצריך לעמוד בהם כשמחשבים מסלולים לרכבים. זה דומה ל-RouteModifiers ב-API המועדף של מסלולים ב-Google Maps Platform. מידע נוסף זמין בכתובת: 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.softMaxLoad כל העלויות מצטברות וצריכות להיות באותה יחידה כמו Shipment.penalty_cost. אפשר להגדיר מגבלות רכות רק על סוגים שחלים על איסופים בלבד או על משלוחים בלבד בכל המודל.
startLoadInterval

object (Interval)

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

object (Interval)

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

string (int64 format)

כמות העומס המקסימלית שניתן לקבל.
costPerKilometer

object (LoadCost)

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

בשלב ניסיוני: פרטים נוספים זמינים בכתובת 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
    }
  }
}

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

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

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

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

לכן, LoadCost במסלול הוא 120.0.

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

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

אז העלות שנוצרה על ידי LoadCost היא

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

במקרה הזה, הערך של LoadCost במסלול הוא 40.0.

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

בשלב ניסיוני: פרטים נוספים זמינים בכתובת 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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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 ספרות אחרי הנקודה. אפשר להשתמש גם בהיסטים אחרים חוץ מ-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

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

ביקור במקור או התנעה של רכב נחשבים להתאמה אם השדה 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

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

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

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

מציין אם האירוע 'first' הוא מסירה.
secondIsDelivery

boolean

מציין אם האירוע ה "שני" הוא מסירה.
offsetDuration

string (Duration format)

ההפרש בין האירוע ה'ראשון' לבין האירוע ה'שני'. הערך יכול להיות שלילי.

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

integer

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

integer

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