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

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