Package google.maps.routeoptimization.v1

אינדקס

RouteOptimization

שירות לאופטימיזציה של סיורים בכלי רכב.

תוקף של סוגי שדות מסוימים:

  • google.protobuf.Timestamp
    • השעות הן לפי שעון יוניקס: שניות מ-1970-01-01T00:00:00+00:00.
    • השניות חייבות להיות ב-[0, 253402300799], כלומר בתוך [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
    • צריך לא להגדיר את הננו או להגדיר אותו ל-0.
  • google.protobuf.Duration
    • השניות חייבות להיות ב-[0, 253402300799], כלומר בתוך [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
    • צריך לא להגדיר את הננו או להגדיר אותו ל-0.
  • google.type.LatLng
    • קו הרוחב חייב להיות [-90.0, 90.0].
    • קו האורך חייב להיות [-180.0, 180.0].
    • לפחות אחד מקווי הרוחב והאורך לא יכול להיות אפס.
BatchOptimizeTours

rpc BatchOptimizeTours(BatchOptimizeToursRequest) returns (Operation)

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

השיטה הזו היא פעולה ממושכת (LRO). הקלט של האופטימיזציה (OptimizeToursRequest הודעות) והפלטים (OptimizeToursResponse הודעות) נקראים/נכתבים מ-Cloud Storage או אל Cloud Storage בפורמט ספציפי למשתמש. בדומה לשיטה OptimizeTours, כל OptimizeToursRequest מכיל ShipmentModel ומחזיר OptimizeToursResponse שמכיל ShipmentRoute. אלה ערכי מסלולים לרכבים שמפחיתים את העלות הכוללת.

היקפי הרשאות

נדרש היקף ההרשאות הבא של OAuth:

  • https://www.googleapis.com/auth/cloud-platform
OptimizeTours

rpc OptimizeTours(OptimizeToursRequest) returns (OptimizeToursResponse)

הפונקציה שולחת OptimizeToursRequest שמכילה ShipmentModel ומחזירה OptimizeToursResponse שמכילה ShipmentRoute. זוהי קבוצת מסלולים לרכבים שמפחיתים את העלות הכוללת שלהם.

מודל ShipmentModel כולל בעיקר פריטי Shipment שצריך לבצע, ומודלים מסוג Vehicle שניתן להשתמש בהם כדי להעביר את מכשירי ה-Shipment. ה-ShipmentRoute מקצים Shipment ל-Vehicle שנ'. באופן ספציפי יותר, הם מקצים סדרה של ערכי Visit לכל רכב, שבהם Visit תואם ל-VisitRequest, שהוא איסוף או משלוח של Shipment.

המטרה היא להקצות ערכי ShipmentRoute ל-Vehicle כדי לצמצם את העלות הכוללת כאשר יש הרבה רכיבים שמוגדרים במאפיין ShipmentModel.

היקפי הרשאות

נדרש היקף ההרשאות הבא של OAuth:

  • https://www.googleapis.com/auth/cloud-platform

AggregatedMetrics

מדדים נצברים עבור ShipmentRoute (רזולוציה עבור OptimizeToursResponse בכל הרכיבים של Transition ו/או Visit (רזולוציה בכל ShipmentRoute).

שדות
performed_shipment_count

int32

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

Duration

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

Duration

משך ההמתנה הכולל למסלול או לפתרון.
delay_duration

Duration

משך ההשהיה הכולל במסלול או בפתרון.
break_duration

Duration

משך ההפסקה הכולל של מסלול או פתרון.
visit_duration

Duration

משך הביקור הכולל במסלול או בפתרון.
total_duration

Duration

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

[ShipmentRoute.vehicle_end_time][google.maps.routeoptimization.v1.ShipmentRoute.vehicle_end_time] - [ShipmentRoute.vehicle_start_time][google.maps.routeoptimization.v1.ShipmentRoute.vehicle_start_time]
travel_distance_meters

double

מרחק הנסיעה הכולל של מסלול או פתרון.
max_loads

map<string, VehicleLoad>

העומס המקסימלי שהושג לאורך המסלול כולו (פתרון תגובה), עבור כל אחת מהכמויות במסלול זה (תמיסת תגובה), מחושב כמקסימלית על כל ה-Transition.vehicle_loads (רזולוציה ShipmentRoute.metrics.max_loads.

BatchOptimizeToursMetadata

אין שדות בסוג הזה.

מטא-נתונים של פעולות לגבי BatchOptimizeToursRequest שיחות.

BatchOptimizeToursRequest

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

שדות
parent

string

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

פורמט: * projects/{project-id} * projects/{project-id}/locations/{location-id}

אם לא יצוין מיקום, האזור ייבחר באופן אוטומטי.
model_configs[]

AsyncModelConfig

חובה. נתוני קלט/פלט של כל מודל רכישה, כמו נתיבי קבצים ופורמטים של נתונים.

AsyncModelConfig

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

שדות
display_name

string

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

InputConfig

חובה. מידע על מודל הקלט.
output_config

OutputConfig

חובה. המידע הרצוי על מיקום הפלט.

BatchOptimizeToursResponse

אין שדות בסוג הזה.

תשובה לBatchOptimizeToursRequest. הערך הזה מוחזר בפעולה ממושכת אחרי שהפעולה מסתיימת.

BreakRule

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

  • במהלך הנסיעה בין שני ביקורים (שכולל את הזמן שממש לפני הביקור או מיד אחריו, אך לא באמצע הביקור), ובמקרה כזה הוא מאריך את זמן ההובלה המתאים בין הביקורים,
  • או לפני ההתנעה של הרכב (יכול להיות שהרכב לא יתחיל באמצע ההפסקה), ובמקרה כזה אין לכך השפעה על שעת ההתחלה של הרכב.
  • או אחרי סיום הרכב (כולל שעת הסיום של הרכב).
שדות
break_requests[]

BreakRequest

רצף של הפסקות. להצגת ההודעה: BreakRequest.
frequency_constraints[]

FrequencyConstraint

ייתכן שיחולו כמה FrequencyConstraint. כולם צריכים להיות מרוצים מהBreakRequest של BreakRule. FrequencyConstraint.

BreakRequest

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

שדות
earliest_start_time

Timestamp

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

Timestamp

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

Duration

חובה. משך הזמן המינימלי של ההפסקה. חייב להיות חיובי.

FrequencyConstraint

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

{
   min_break_duration { seconds: 3600 }         # 1 hour.
   max_inter_break_duration { seconds: 39600 }  # 11 hours (12 - 1 = 11).
}

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

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

  04:00 vehicle start
   .. performing travel and visits ..
  09:00 1 hour break
  10:00 end of the break
   .. performing travel and visits ..
  12:00 20-min lunch break
  12:20 end of the break
   .. performing travel and visits ..
  21:00 1 hour break
  22:00 end of the break
   .. performing travel and visits ..
  23:59 vehicle end
שדות
min_break_duration

Duration

חובה. משך ההפסקה המינימלי לאילוץ הזה. לא שלילי. הצגת התיאור של FrequencyConstraint.
max_inter_break_duration

Duration

חובה. הטווח המרבי המותר של כל מרווח זמן במסלול לא כולל לפחות הפסקה חלקית של duration >= min_break_duration. חייב להיות חיובי.

DataFormat

פורמטים של נתונים לקובצי קלט ופלט.

טיפוסים בני מנייה (enums)
DATA_FORMAT_UNSPECIFIED ערך לא חוקי, הפורמט לא יכול להיות UNSPECIFIED.
JSON סימון אובייקט JavaScript.
PROTO_TEXT פורמט טקסט של מאגרי פרוטוקולים. פרטים נוספים זמינים בכתובת https://protobuf.dev/reference/protobuf/textformat-spec/.

DistanceLimit

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

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

שדות
max_meters

int64

קיימת הגבלה קשיחה שמגבילה את המרחק ל-max_meters. המגבלה חייבת להיות מספר שאינו שלילי.
soft_max_meters

int64

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

אם מגדירים ערך של soft_max_meters, הערך צריך להיות קטן מ-max_meters וחייב להיות מספר לא שלילי.
cost_per_kilometer_above_soft_max

double

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

  (distance_meters - soft_max_meters) / 1000.0 *
  cost_per_kilometer_above_soft_max.

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

GcsDestination

המיקום של Google Cloud Storage שבו ייכתבו קובצי הפלט.

שדות
uri

string

חובה. URI של Google Cloud Storage.

GcsSource

המיקום של Google Cloud Storage שממנו יוקרא קובץ הקלט.

שדות
uri

string

חובה. URI של אובייקט Google Cloud Storage בפורמט gs://bucket/path/to/object.

InjectedSolutionConstraint

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

שדות
routes[]

ShipmentRoute

מסלולים של התמיסה שיש להחדיר. ייתכן שחלק מהמסלולים יושמטו מהפתרון המקורי. המסלולים והמשלוחים שעליהם דילגו חייבים לעמוד בהנחות התקינות הבסיסיות שמפורטות עבור injected_first_solution_routes.
skipped_shipments[]

SkippedShipment

דילגת על משלוחים של התמיסה שיש להחדיר. ייתכן שחלק מהם יושמטו מהפתרון המקורי. פרטים נוספים זמינים בשדה routes.
constraint_relaxations[]

ConstraintRelaxation

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

ConstraintRelaxation

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

שדות
relaxations[]

Relaxation

כל ההקלות במגבלות הביקורים שיחולו על ביקורים במסלולים עם כלי רכב בvehicle_indices.
vehicle_indices[]

int32

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

אינדקס רכב ממופה באופן זהה ל-ShipmentRoute.vehicle_index, אם interpret_injected_solutions_using_labels הוא True (יש לעיין בהערה fields).

הירגעות

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

relaxations(i).level מציין את רמת ההקלות של האילוץ שהוחלה על ביקור #j שעומד בתנאים הבאים:

  • route.visits(j).start_time >= relaxations(i).threshold_time וגם
  • j + 1 >= relaxations(i).threshold_visit_count

באופן דומה, ההתנעה של הרכב משוחררת ל-relaxations(i).level אם היא עומדת בדרישות הבאות:

  • vehicle_start_time >= relaxations(i).threshold_time וגם
  • relaxations(i).threshold_visit_count == 0 ובקצה הרכב משוחררים ל-relaxations(i).level אם הוא עומד בדרישות הבאות:
  • vehicle_end_time >= relaxations(i).threshold_time וגם
  • route.visits_size() + 1 >= relaxations(i).threshold_visit_count

כדי להחיל רמת רגיעה אם ביקור תואם ל-threshold_visit_count או ל-threshold_time, צריך להוסיף שני relaxations עם אותו level: באחד מהם מוגדר רק threshold_visit_count ובשני עם רק threshold_time. אם הביקור עומד בתנאים של מספר relaxations, תחול הרמה הרגועה ביותר. כתוצאה מכך, מרגע שהרכב מתחיל בביקורים במסלול ועד לסיום המסלול, רמת הרגיעה הופכת לרגועה יותר: כלומר, רמת הרגיעה לא יורדת ככל שהמסלול מתקדם.

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

שדות
level

Level

רמת ההקלות של האילוצים שחלה כאשר מתקיימים התנאים של threshold_time או אחריהם וגם של threshold_visit_count לפחות.
threshold_time

Timestamp

השעה שבה או לאחר מכן תחול ההקלות level.
threshold_visit_count

int32

מספר הביקורים שעליהם תחול ההקלות level או לאחר מכן. אם הערך של threshold_visit_count הוא 0 (או לא מוגדר), אפשר להחיל את level ישירות בהתחלה של הרכב.

אם הוא route.visits_size() + 1, ניתן להחיל את level רק על קצה הרכב. אם הוא יותר מ-route.visits_size() + 1, אז level לא מיושם בכלל במסלול הזה.

רמה

מבטא את רמות ההקלות השונות באילוץ, שחלות על ביקור ועל אלה שיתרחשו לאחר עמידה בתנאי הסף.

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

טיפוסים בני מנייה (enums)
LEVEL_UNSPECIFIED

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

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

InputConfig

יש לציין קלט ל-[BatchOptimizeTours][google.maps.routeoptimization.v1.RouteOptimizationService.BatchOptimizeTours].

שדות
data_format

DataFormat

חובה. פורמט נתוני הקלט.
שדה איחוד source. חובה. source יכול להיות רק אחד מהבאים:
gcs_source

GcsSource

מיקום של Google Cloud Storage. עליו להיות אובייקט יחיד (קובץ).

מיקום

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

שדות
lat_lng

LatLng

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

int32

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

OptimizeToursRequest

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

שדות
parent

string

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

פורמט: * projects/{project-id} * projects/{project-id}/locations/{location-id}

אם לא יצוין מיקום, האזור ייבחר באופן אוטומטי.
timeout

Duration

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

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

ShipmentModel

מודל המשלוח שצריך לפתור.
solving_mode

SolvingMode

כברירת מחדל, מצב הפתרון הוא DEFAULT_SOLVE (0).
search_mode

SearchMode

מצב החיפוש ששימש לפתרון הבקשה.
injected_first_solution_routes[]

ShipmentRoute

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

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

הפתרון חייב לעמוד בכמה הנחות תקפות בסיסיות:

  • עבור כל המסלולים, הערך vehicle_index חייב להיות בטווח ובלי לשכפל אותו.
  • עבור כל הביקורים, shipment_index ו-visit_request_index חייבים להיות בטווח.
  • ניתן לציין משלוח רק במסלול אחד.
  • האיסוף של משלוח באיסוף עצמי חייב להתבצע לפני המסירה.
  • אין לבצע יותר מחלופה אחת לאיסוף או חלופי משלוח של משלוח.
  • לכל המסלולים, הזמנים גדלים (כלומר vehicle_start_time <= visits[0].start_time <= visits[1].start_time ... <= vehicle_end_time).
  • ניתן לבצע משלוח רק בכלי רכב שמותר. מותר להוסיף רכב אם השדה Shipment.allowed_vehicle_indices ריק או אם נכס vehicle_index כלול ביעד Shipment.allowed_vehicle_indices.

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

InjectedSolutionConstraint

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

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

ShipmentRoute

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

החל מ-11 במרץ 2020, השדה הזה מאכלס רק את הקווים הפוליגוניים של מסלולים שאינם ריקים ומחייב את הערך populate_polylines.

יכול להיות שהשדות route_polyline במסלולים שהועברו לא תואמים למסלול transitions.

אין להשתמש בשדה הזה יחד עם injected_first_solution_routes או עם injected_solution_constraint.

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

bool

אם הערך הוא נכון:

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

אם הערך הוא True, התוויות בקטגוריות הבאות חייבות להופיע לכל היותר פעם אחת בקטגוריה שלהן:

אם vehicle_label בפתרון שהוחדר לא תואם לרכב בקשה, המסלול המתאים יוסר מהפתרון יחד עם הביקורים שלו. אם הערך shipment_label בפתרון שהוחדר לא תואם לבקשת משלוח, הביקור התואם יוסר מהפתרון. אם הערך SkippedShipment.label בתמיסה שהוחדר לא תואם לבקשת משלוח, SkippedShipment מוסר מהפתרון.

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

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

bool

מומלץ לשקול את הערכת התנועה בעת חישוב שדות ShipmentRoute Transition.travel_duration, Visit.start_time ו-vehicle_end_time; בהגדרת השדה ShipmentRoute.has_traffic_infeasibilities ובחישוב השדה OptimizeToursResponse.total_cost.
populate_polylines

bool

אם הערך הוא True, קווים פוליגוניים יאוכלסו בתשובה מסוג ShipmentRoute.
populate_transition_polylines

bool

אם הערך הוא True, קווים פוליגוניים יאוכלסו בתשובה ShipmentRoute.transitions.
allow_large_deadline_despite_interruption_risk

bool

אם מגדירים את האפשרות הזו, תאריך היעד של הבקשה (מידע נוסף זמין בכתובת https://grpc.io/blog/deadlines) יכול להיות עד 60 דקות. אחרת, תאריך היעד המקסימלי הוא 30 דקות בלבד. שימו לב שהסיכון להפרעות בשליחת בקשות לאורך זמן ארוך משמעותית (אבל עדיין נמוך).
use_geodesic_distances

bool

אם הערך הוא true, מרחקים יחושבו באמצעות מרחקים גיאודזיים במקום מרחקים של מפות Google, וזמני הנסיעה יחושבו באמצעות מרחקים גיאודזיים עם מהירות המוגדרת על ידי geodesic_meters_per_second.
label

string

התווית שייתכן שתשמש לזיהוי הבקשה הזו, תדווח בחזרה ב-OptimizeToursResponse.request_label.
geodesic_meters_per_second

double

אם הערך של use_geodesic_distances הוא TRUE, צריך להגדיר את השדה הזה ומגדיר את המהירות שמיושמת על מנת לחשב את זמני הנסיעה. הערך שלו חייב להיות לפחות 1.0 מטר לשנייה.
max_validation_errors

int32

חיתוך מספר שגיאות האימות שהוחזרו. השגיאות האלה מצורפות בדרך כלל למטען ייעודי (payload) של שגיאות INVALID_ARGUMENT כפרטי שגיאה של BadRequest (https://cloud.google.com/apis/design/errors#error_details), אלא אם הבעיה resolve_mode=LEGALATE_ONLY: יש לעיין בשדה OptimizeToursResponse.validation_errors. ערך ברירת המחדל הוא 100, והוא מוגבל ל-10,000.

SearchMode

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

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

SolvingMode

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

טיפוסים בני מנייה (enums)
DEFAULT_SOLVE פותרים את המודל.
VALIDATE_ONLY מאמת את המודל רק בלי לפתור אותו: מאכלס כמה שיותר OptimizeToursResponse.validation_errors.
DETECT_SOME_INFEASIBLE_SHIPMENTS

תאכלס רק OptimizeToursResponse.validation_errors או OptimizeToursResponse.skipped_shipments, ולא פותר בפועל את שאר הבקשה (status ו-routes לא מוגדרים בתגובה). אם נזהה אי-נוחות במסלולים injected_solution_constraint, הם יאוכלסו בשדה OptimizeToursResponse.validation_errors ו-OptimizeToursResponse.skipped_shipments יישאר ריק.

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

OptimizeToursResponse

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

שדות
routes[]

ShipmentRoute

נתיבים המחושבים עבור כל רכב. המסלול ה-i תואם לרכב ה-i שבמודל.
request_label

string

עותק של OptimizeToursRequest.label, אם צוינה תווית בבקשה.
skipped_shipments[]

SkippedShipment

רשימת כל המשלוחים דילגה.
validation_errors[]

OptimizeToursValidationError

רשימה של כל שגיאות האימות שהצלחנו לזהות בנפרד. כדאי לעיין בהסבר 'מספר שגיאות' לגבי ההודעה OptimizeToursValidationError.
metrics

Metrics

מדדי משך הזמן, המרחק והשימוש בפתרון הזה.

מדדים

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

שדות
aggregated_route_metrics

AggregatedMetrics

הנתון הזה נצבר במסלולים. כל מדד הוא הסכום (או המקסימלי, של טעינות) של כל השדות ShipmentRoute.metrics בעלי אותו שם.
skipped_mandatory_shipment_count

int32

מספר המשלוחי החובה שדילגת עליהם.
used_vehicle_count

int32

מספר כלי הרכב שהיו בשימוש. הערה: אם מסלול הרכב ריק והמאפיין Vehicle.used_if_route_is_empty הוא True, הרכב נחשב משומש.
earliest_vehicle_start_time

Timestamp

שעת ההתחלה המוקדמת ביותר של רכב משומש, מחושבת כמהירות המינימלית לכל כלי הרכב המשומשים ב-ShipmentRoute.vehicle_start_time.
latest_vehicle_end_time

Timestamp

שעת הסיום העדכנית ביותר של רכב משומש, מחושבת כשעת הסיום המקסימלית בכל כלי הרכב המשומשים של ShipmentRoute.vehicle_end_time.
costs

map<string, double>

עלות הפתרון, בחלוקה לפי שדות בקשה הקשורים לעלות. המפתחות הם נתיבים של תבניות אב, ביחס לקלט OptimizeToursRequest, למשל "model.shipments.pickups.cost". הערכים הם העלות הכוללת שנוצרה על-ידי שדה העלות המתאים, שנצברת על פני הפתרון כולו. במילים אחרות, העלויות ["model.shipments.pickups.cost"] הן הסכום של כל עלויות האיסוף ביחס לפתרון. כל העלויות שמוגדרות במודל מדווחות כאן בפירוט, חוץ מהעלויות שקשורות למאפייני מעבר, שמדווחות רק באופן מצטבר החל מ-1 בינואר 2022.
total_cost

double

העלות הכוללת של הפתרון. סכום כל הערכים במפת העלויות.

OptimizeToursValidationError

מתאר שגיאה שאירעה במהלך אימות OptimizeToursRequest.

שדות
code

int32

שגיאת אימות מוגדרת על ידי הצמד (code, display_name) שתמיד נמצאים.

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

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

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

הפניה: רשימה של כל הצמדים (קוד, שם):

  • UNSPECIFIED = 0;
  • TRUEATION_TOTAL_ERROR = 10; לא ניתן היה להשלים את האימות במהלך המועד האחרון.

  • REQUEST_OPTIONS_ERROR = 12;

    • REQUEST_OPTIONS_INVALID_SOLVING_mode = 1201;
    • REQUEST_OPTIONS_INVALID_MAX_LEGALATION_ERRORS = 1203;
    • REQUEST_OPTIONS_INVALID_YOUDESIC_METERS_PER_SECOND = 1204;
    • REQUEST_OPTIONS_geoDESIC_METERS_PER_SECOND_TOO_ לכם = 1205;
    • REQUEST_OPTIONS_MISSING_geoDESIC_METERS_PER_SECOND = 1206;
    • REQUEST_OPTIONS_POPULATE_PATHFINDER_TRIPS_AND_geoDESIC_DISTANCE = 1207;
    • REQUEST_OPTIONS_cost_MODEL_OPTIONS_AND_YOUDESIC_DISTANCE = 1208;
    • REQUEST_OPTIONS_TRAVEL_mode_INCOMPATIBLE_WITH_TRAFFIC = 1211;
    • REQUEST_OPTIONS_MULTIPLE_TRAFFIC_FLAVORS = 1212;
    • REQUEST_OPTIONS_INVALID_TRAFFIC_FLAVOR = 1213;
    • REQUEST_OPTIONS_TRAFFIC_ENABLED_WITHOUT_GLOBAL_START_TIME = 1214;
    • REQUEST_OPTIONS_TRAFFIC_ENABLED_WITH_PRECEDENCES = 1215;
    • REQUEST_OPTIONS_TRAFFIC_PREFILL_mode_INVALID = 1216;
    • REQUEST_OPTIONS_TRAFFIC_PREFILL_ENABLED_WITHOUT_TRAFFIC = 1217;
  • INJECTED_SOLUTION_ERROR = 20;
    • INJECTED_SOLUTION_MISSING_LABEL = 2000;
    • INJECTED_SOLUTION_DUPLICATE_LABEL = 2001;
    • INJECTED_SOLUTION_AMBIGUOUS_INDEX = 2002;
    • INJECTED_SOLUTION_INFEASIBLE_AFTER_GETTING_TRAVEL_TIMES = 2003;
    • INJECTED_SOLUTION_TRANSITION_INCONSISTENT_WITH_ מהמכשירים = 2004;
    • INJECTED_SOLUTION_CONCURRENT_SOLUTION_TYPES = 2005;
    • INJECTED_SOLUTION_MORE_THAN_ONE_PER_TYPE = 2006;
    • INJECTED_SOLUTION_REFRESH_WITHOUT_POPULATE = 2008;
    • INJECTED_SOLUTION_CONSTRAINED_ROUTE_PORTION_INFEASIBLE = 2010;
  • SHIPMENT_MODEL_ERROR = 22;
    • SHIPMENT_MODEL_TOO_LARGE = 2200;
    • SHIPMENT_MODEL_TOO_MANY_CAPACITY_TYPES = 2201;
    • SHIPMENT_MODEL_GLOBAL_START_TIME_NEGATIVE_OR_NAN = 2202;
    • SHIPMENT_MODEL_GLOBAL_END_TIME_TOO_LARGE_OR_NAN = 2203;
    • SHIPMENT_MODEL_GLOBAL_START_TIME_AFTER_GLOBAL_END_TIME = 2204;
    • SHIPMENT_MODEL_GLOBAL_DURATION_TOO_long = 2205;
    • SHIPMENT_MODEL_MAX_ACTIVE_VEHICLES_NOT_POSITIVE = 2206;
    • SHIPMENT_MODEL_DURATION_MATRIX_TOO_LARGE = 2207;
  • INDEX_ERROR = 24;
  • TAG_ERROR = 26;
  • TIME_WINDOW_ERROR = 28;
    • TIME_WINDOW_INVALID_START_TIME = 2800;
    • TIME_WINDOW_INVALID_END_TIME = 2801;
    • TIME_WINDOW_INVALID_SOFT_START_TIME = 2802;
    • TIME_WINDOW_INVALID_SOFT_END_TIME = 2803;
    • TIME_WINDOW_OUTSIDE_GLOBAL_TIME_WINDOW = 2804;
    • TIME_WINDOW_START_TIME_AFTER_END_TIME = 2805;
    • TIME_WINDOW_INVALID_cost_PER_HOUR_BEFORE_SOFT_START_TIME = 2806;
    • TIME_WINDOW_INVALID_cost_PER_HOUR_AFTER_SOFT_END_TIME = 2807;
    • TIME_WINDOW_cost_BEFORE_SOFT_START_TIME_WITHOUT_SOFT_START_TIME = 2808;
    • TIME_WINDOW_cost_AFTER_SOFT_END_TIME_WITHOUT_SOFT_END_TIME = 2809;
    • TIME_WINDOW_SOFT_START_TIME_WITHOUT_cost_BEFORE_SOFT_START_TIME = 2810;
    • TIME_WINDOW_SOFT_END_TIME_WITHOUT_cost_AFTER_SOFT_END_TIME = 2811;
    • TIME_WINDOW_OVERLAPPING_ADJACENT_OR_EARLIER_THAN_PREVIOUS = 2812;
    • TIME_WINDOW_START_TIME_AFTER_SOFT_START_TIME = 2813;
    • TIME_WINDOW_SOFT_START_TIME_AFTER_END_TIME = 2814;
    • TIME_WINDOW_START_TIME_AFTER_SOFT_END_TIME = 2815;
    • TIME_WINDOW_SOFT_END_TIME_AFTER_END_TIME = 2816;
    • TIME_WINDOW_cost_BEFORE_SOFT_START_TIME_SET_AND_MULTIPLE_WINDOWS = 2817;
    • TIME_WINDOW_cost_AFTER_SOFT_END_TIME_SET_AND_MULTIPLE_WINDOWS = 2818;
    • TRANSITION_ATTRIBUTES_ERROR = 30;
    • TRANSITION_ATTRIBUTES_INVALID_cost = 3000;
    • TRANSITION_ATTRIBUTES_INVALID_cost_PER_KILOMETER = 3001;
    • TRANSITION_ATTRIBUTES_DUPLICATE_TAG_PAIR = 3002;
    • TRANSITION_ATTRIBUTES_DISTANCE_LIMIT_MAX_METERS_UNSUPPORTED = 3003;
    • TRANSITION_ATTRIBUTES_UNSPECIFIED_SOURCE_TAGS = 3004;
    • TRANSITION_ATTRIBUTES_ {/9}ING_SOURCE_TAGS_FIELDS = 3005;
    • TRANSITION_ATTRIBUTES_UNSPECIFIED_DESTINATION_TAGS = 3006;
    • TRANSITION_ATTRIBUTES_ {/9}ING_DESTINATION_TAGS_FIELDS = 3007;
    • TRANSITION_ATTRIBUTES_PENDING_DURATION_NEGATIVE_OR_NAN = 3008;
    • TRANSITION_ATTRIBUTES_SENDER_DURATION_EXCEEDS_GLOBAL_DURATION = 3009;
  • AMOUNT_ERROR = 31;
    • AMOUNT_NEGATIVE_VALUE = 3100;
  • LOAD_LIMIT_ERROR = 33;
    • LOAD_LIMIT_INVALID_cost_ABOVE_SOFT_MAX = 3303;
    • LOAD_LIMIT_SOFT_MAX_WITHOUT_cost_ABOVE_SOFT_MAX = 3304;
    • LOAD_LIMIT_cost_ABOVE_SOFT_MAX_WITHOUT_SOFT_MAX = 3305;
    • LOAD_LIMIT_NEGATIVE_SOFT_MAX = 3306;
    • LOAD_LIMIT_MIXED_DEMAND_TYPE = 3307;
    • LOAD_LIMIT_MAX_LOAD_NEGATIVE_VALUE = 3308;
    • LOAD_LIMIT_SOFT_MAX_ABOVE_MAX = 3309;
  • INTERVAL_ERROR = 34;
    • INTERVAL_MIN_EXCEEDS_MAX = 3401;
    • INTERVAL_NEGATIVE_MIN = 3402;
    • INTERVAL_NEGATIVE_MAX = 3403;
    • INTERVAL_MIN_EXCEEDS_CAPACITY = 3404;
    • INTERVAL_MAX_EXCEEDS_CAPACITY = 3405;
  • DISTANCE_LIMIT_ERROR = 36;
    • DISTANCE_LIMIT_INVALID_cost_AFTER_SOFT_MAX = 3601;
    • DISTANCE_LIMIT_SOFT_MAX_WITHOUT_cost_AFTER_SOFT_MAX = 3602;
    • DISTANCE_LIMIT_cost_AFTER_SOFT_MAX_WITHOUT_SOFT_MAX = 3603;
    • DISTANCE_LIMIT_NEGATIVE_MAX = 3604;
    • DISTANCE_LIMIT_NEGATIVE_SOFT_MAX = 3605;
    • DISTANCE_LIMIT_SOFT_MAX_LARGER_THAN_MAX = 3606;
  • DURATION_LIMIT_ERROR = 38;
    • DURATION_LIMIT_MAX_DURATION_NEGATIVE_OR_NAN = 3800;
    • DURATION_LIMIT_SOFT_MAX_DURATION_NEGATIVE_OR_NAN = 3801;
    • DURATION_LIMIT_INVALID_cost_PER_HOUR_AFTER_SOFT_MAX = 3802;
    • DURATION_LIMIT_SOFT_MAX_WITHOUT_cost_AFTER_SOFT_MAX = 3803;
    • DURATION_LIMIT_cost_AFTER_SOFT_MAX_WITHOUT_SOFT_MAX = 3804;
    • DURATION_LIMIT_QUADRATIC_SOFT_MAX_DURATION_NEGATIVE_OR_NAN = 3805;
    • DURATION_LIMIT_INVALID_cost_AFTER_QUADRATIC_SOFT_MAX = 3806;
    • DURATION_LIMIT_QUADRATIC_SOFT_MAX_WITHOUT_cost_PER_PARTY_HOUR = 3807;
    • DURATION_LIMIT_cost_PER_PARTY_HOUR_WITHOUT_QUADRATIC_SOFT_MAX = 3808;
    • DURATION_LIMIT_QUADRATIC_SOFT_MAX_WITHOUT_MAX = 3809;
    • DURATION_LIMIT_SOFT_MAX_LARGER_THAN_MAX = 3810;
    • DURATION_LIMIT_QUADRATIC_SOFT_MAX_LARGER_THAN_MAX = 3811;
    • DURATION_LIMIT_DIFF_BETWEEN_MAX_AND_QUADRATIC_SOFT_MAX_TOO_LARGE = 3812;
    • DURATION_LIMIT_MAX_DURATION_EXCEEDS_GLOBAL_DURATION = 3813;
    • DURATION_LIMIT_SOFT_MAX_DURATION_EXCEEDS_GLOBAL_DURATION = 3814;
    • DURATION_LIMIT_QUADRATIC_SOFT_MAX_DURATION_EXCEEDS_GLOBAL_DURATION = 3815;
  • SHIPMENT_ERROR = 40;
    • SHIPMENT_PD_LIMIT_WITHOUT_PICKUP_AND_delivery = 4014;
    • SHIPMENT_PD_ABSOLUTE_DETOUR_LIMIT_DURATION_NEGATIVE_OR_NAN = 4000;
    • SHIPMENT_PD_ABSOLUTE_DETOUR_LIMIT_DURATION_EXCEEDS_GLOBAL_DURATION = 4001;
    • SHIPMENT_PD_RELATIVE_DETOUR_LIMIT_INVALID = 4015;
    • SHIPMENT_PD_DETOUR_LIMIT_AND_Ext_VISIT_DURATION = 4016;
    • SHIPMENT_PD_TIME_LIMIT_DURATION_NEGATIVE_OR_NAN = 4002;
    • SHIPMENT_PD_TIME_LIMIT_DURATION_EXCEEDS_GLOBAL_DURATION = 4003;
    • SHIPMENT_EMPTY_SHIPMENT_TYPE = 4004;
    • SHIPMENT_NO_PICKUP_NO_delivery = 4005;
    • SHIPMENT_INVALID_PENALTY_cost = 4006;
    • SHIPMENT_ALLOWED_VEHICLE_INDEX_OUT_OF_BOUNDS = 4007;
    • SHIPMENT_DUPLICATE_ALLOWED_VEHICLE_INDEX = 4008;
    • SHIPMENT_INCONSISTENT_cost_FOR_VEHICLE_SIZE_WITHOUT_INDEX = 4009;
    • SHIPMENT_INCONSISTENT_cost_FOR_VEHICLE_SIZE_WITH_INDEX = 4010;
    • SHIPMENT_INVALID_cost_FOR_VEHICLE = 4011;
    • SHIPMENT_cost_FOR_VEHICLE_INDEX_OUT_OF_BOUNDS = 4012;
    • SHIPMENT_DUPLICATE_cost_FOR_VEHICLE_INDEX = 4013;
  • VEHICLE_ERROR = 42;
    • VEHICLE_EMPTY_REQUIRED_OPERATOR_TYPE = 4200;
    • VEHICLE_DUPLICATE_REQUIRED_OPERATOR_TYPE = 4201;
    • VEHICLE_NO_OPERATOR_WITH_REQUIRED_OPERATOR_TYPE = 4202;
    • VEHICLE_EMPTY_START_TAG = 4203;
    • VEHICLE_DUPLICATE_START_TAG = 4204;
    • VEHICLE_EMPTY_END_TAG = 4205;
    • VEHICLE_DUPLICATE_END_TAG = 4206;
    • VEHICLE_additional_VISIT_DURATION_NEGATIVE_OR_NAN = 4207;
    • VEHICLE_additional_VISIT_DURATION_EXCEEDS_GLOBAL_DURATION = 4208;
    • VEHICLE_additional_VISIT_DURATION_EMPTY_KEY = 4209;
    • VEHICLE_FIRST_SHIPMENT_INDEX_OUT_OF_BOUNDS = 4210;
    • VEHICLE_FIRST_SHIPMENT_IGNORED = 4211;
    • VEHICLE_FIRST_SHIPMENT_NOT_BOUND = 4212;
    • VEHICLE_LAST_SHIPMENT_INDEX_OUT_OF_BOUNDS = 4213;
    • VEHICLE_LAST_SHIPMENT_IGNORED = 4214;
    • VEHICLE_LAST_SHIPMENT_NOT_BOUND = 4215;
    • VEHICLE_IGNORED_WITH_USED_IF_ROUTE_IS_EMPTY = 4216;
    • VEHICLE_INVALID_cost_PER_KILOMETER = 4217;
    • VEHICLE_INVALID_cost_PER_HOUR = 4218;
    • VEHICLE_INVALID_cost_PER_TRAVELED_HOUR = 4219;
    • VEHICLE_INVALID_FIXED_cost = 4220;
    • VEHICLE_INVALID_TRAVEL_DURATION_MULTIPLE = 4221;
    • VEHICLE_TRAVEL_DURATION_MULTIPLE_WITH_SHIPMENT_PD_DETOUR_LIMITS = 4223;
    • VEHICLE_MATRIX_INDEX_WITH_SHIPMENT_PD_DETOUR_LIMITS = 4224;
    • VEHICLE_PARENT_DURATION_CPCER_THAN_DURATION_LIMIT = 4222 ;
  • VISIT_REQUEST_ERROR = 44;
    • VISIT_REQUEST_EMPTY_TAG = 4400;
    • VISIT_REQUEST_DUPLICATE_TAG = 4401;
    • VISIT_REQUEST_DURATION_NEGATIVE_OR_NAN = 4404;
    • VISIT_REQUEST_DURATION_EXCEEDS_GLOBAL_DURATION = 4405;
  • PRECEDENCE_ERROR = 46;
  • BREAK_ERROR = 48;
    • BREAK_MANAGE_EMPTY = 4800;
    • BREAK_REQUEST_UNSPECIFIED_DURATION = 4801;
    • BREAK_REQUEST_UNSPECIFIED_EARLIEST_START_TIME = 4802;
    • BREAK_REQUEST_UNSPECIFIED_LATEST_START_TIME = 4803;
    • BREAK_REQUEST_DURATION_NEGATIVE_OR_NAN = 4804; = 4804;
    • BREAK_REQUEST_LATEST_START_TIME_BEFORE_EARLIEST_START_TIME = 4805;
    • BREAK_REQUEST_EARLIEST_START_TIME_BEFORE_GLOBAL_START_TIME = 4806;
    • BREAK_REQUEST_LATEST_END_TIME_AFTER_GLOBAL_END_TIME = 4807;
    • BREAK_REQUEST_NON_SCHEDULABLE = 4808;
    • BREAK_Frequency_MAX_INTER_BREAK_DURATION_NEGATIVE_OR_NAN = 4809;
    • BREAK_PROGRESS_MIN_BREAK_DURATION_NEGATIVE_OR_NAN = 4810;
    • BREAK_PROGRESS_MIN_BREAK_DURATION_EXCEEDS_GLOBAL_DURATION = 4811;
    • BREAK_Frequency_MAX_INTER_BREAK_DURATION_EXCEEDS_GLOBAL_DURATION = 4812;
    • BREAK_REQUEST_DURATION_EXCEEDS_GLOBAL_DURATION = 4813;
    • BREAK_Frequency_MISSING_MAX_INTER_BREAK_DURATION = 4814;
    • BREAK_Frequency_MISSING_MIN_BREAK_DURATION = 4815;
  • SHIPMENT_TYPE_INCOMPATIBILITY_ERROR = 50;
    • SHIPMENT_TYPE_INCOMPATIBILITY_EMPTY_TYPE = 5001;
    • SHIPMENT_TYPE_INCOMPATIBILITY_LESS_THAN_TWO_TYPES = 5002;
    • SHIPMENT_TYPE_INCOMPATIBILITY_DUPLICATE_TYPE = 5003;
    • SHIPMENT_TYPE_INCOMPATIBILITY_INVALID_INCOMPATIBILITY_mode = 5004;
    • SHIPMENT_TYPE_INCOMPATIBILITY_TOO_MANY_INCOMPATIBILITIES = 5005;
  • SHIPMENT_TYPE_REQUIREMENT_ERROR = 52;
    • SHIPMENT_TYPE_REQUIREMENT_NO_REQUIRED_TYPE = 52001;
    • SHIPMENT_TYPE_REQUIREMENT_NO_DEPENDENT_TYPE = 52002;
    • SHIPMENT_TYPE_REQUIREMENT_INVALID_REQUIREMENT_mode = 52003;
    • SHIPMENT_TYPE_REQUIREMENT_TOO_MANY_REQUIREMENTS = 52004;
    • SHIPMENT_TYPE_REQUIREMENT_EMPTY_REQUIRED_TYPE = 52005;
    • SHIPMENT_TYPE_REQUIREMENT_DUPLICATE_REQUIRED_TYPE = 52006;
    • SHIPMENT_TYPE_REQUIREMENT_NO_REQUIRED_TYPE_FOUND = 52007;
    • SHIPMENT_TYPE_REQUIREMENT_EMPTY_DEPENDENT_TYPE = 52008;
    • SHIPMENT_TYPE_REQUIREMENT_DUPLICATE_DEPENDENT_TYPE = 52009;
    • SHIPMENT_TYPE_REQUIREMENT_SELF_DEPENDENT_TYPE = 52010;
    • SHIPMENT_TYPE_REQUIREMENT_GRAPH_HAS_CYCLES = 52011;
  • VEHICLE_OPERATOR_ERROR = 54;
    • VEHICLE_OPERATOR_EMPTY_TYPE = 5400;
    • VEHICLE_OPERATOR_MULTIPLE_START_TIME_WINDOWS = 5401;
    • VEHICLE_OPERATOR_SOFT_START_TIME_WINDOW = 5402;
    • VEHICLE_OPERATOR_MULTIPLE_END_TIME_WINDOWS = 5403;
    • VEHICLE_OPERATOR_SOFT_END_TIME_WINDOW = 5404;
  • DURATION_SECONDS_MATRIX_ERROR = 56;
    • DURATION_SECONDS_MATRIX_DURATION_NEGATIVE_OR_NAN = 5600;
    • DURATION_SECONDS_MATRIX_DURATION_EXCEEDS_GLOBAL_DURATION = 5601;
display_name

string

השם המוצג של השגיאה.
fields[]

FieldReference

הקשר של שגיאה עשוי לכלול שדות של 0, 1 (ברוב המקרים) או יותר. לדוגמה, אם מדובר ברכב מס' 4 ובאיסוף הראשון של משלוח מס' 2, אפשר לבצע את הפעולות הבאות:

fields { name: "vehicles" index: 4}
fields { name: "shipments" index: 2 sub_field {name: "pickups" index: 0} }

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

string

מחרוזת לתיאור השגיאה, שאנשים יכולים לקרוא. קיים מיפוי ביחס של 1:1 בין code לבין error_message (כאשר הקוד != "UNSPECIFIED").

יציבות: לא יציבה: הודעת השגיאה המשויכת ל-code נתון עשויה להשתנות (בתקווה להבהיר זאת) עם הזמן. במקום זאת, יש להסתמך על display_name ועל code.
offending_values

string

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

FieldReference

מציין את ההקשר של שגיאת האימות. השדה FieldReference תמיד מתייחס לשדה נתון בקובץ הזה, לפי אותו מבנה היררכי. לדוגמה, אפשר לציין את רכיב מס' 2 מתוך start_time_windows של רכב מס' 5 באמצעות:

name: "vehicles" index: 5 sub_field { name: "end_time_windows" index: 2 }

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

שדות
name

string

שם השדה, למשל 'כלי רכב'.
sub_field

FieldReference

שדה משנה מקונן באופן רקורסיבי, אם יש צורך.

שדה איחוד index_or_key.

index_or_key יכול להיות רק אחד מהבאים:
index

int32

אינדקס השדה, אם הוא חוזר.
key

string

מקש אם השדה הוא מפה.

OutputConfig

ציון יעד לתוצאות של [BatchOptimizeTours][google.maps.routeoptimization.v1.RouteOptimizationService.BatchOptimizeTours].

שדות
data_format

DataFormat

חובה. הפורמט של נתוני הפלט.
שדה איחוד destination. חובה. destination יכול להיות רק אחד מהבאים:
gcs_destination

GcsDestination

המיקום של Google Cloud Storage שבו צריך לכתוב את הפלט.

משלוח

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

שדות
display_name

string

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

VisitRequest

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

VisitRequest

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

map<string, Load>

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

int32

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

double

מציין את העלות של שליחת המשלוח על ידי כל אחד מכלי הרכב. אם צוין, חייב להיות לו EITHER:

  • אותו מספר רכיבים כמו costs_per_vehicle_indices. costs_per_vehicle[i] תואם לרכב costs_per_vehicle_indices[i] של המודל.
  • אותו מספר רכיבים כמו שיש כלי רכב במודל. הרכיב ה-i תואם לרכב מס' i של המודל.

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

int32

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

Duration

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

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

start_time(delivery) - start_time(pickup) <=
t + pickup_to_delivery_absolute_detour_limit

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

Duration

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

string

מחרוזת שאינה ריקה, שמציינת 'סוג' למשלוח הזה. אפשר להשתמש בתכונה הזו כדי להגדיר חוסר תאימות או דרישות בין shipment_types (מידע נוסף זמין בקטע shipment_type_incompatibilities עד shipment_type_requirements בShipmentModel).

שונה מהערך visit_types שצוין לביקור יחיד: כל האיסוף/המשלוחים השייכים לאותו משלוח חולקים את אותו shipment_type.
label

string

מציין תווית למשלוח. התווית הזו מדווחת בתגובה ב-shipment_label של ה-ShipmentRoute.Visit התואמת.
ignore

bool

אם הערך הוא true, דלגו על המשלוח הזה, אבל אל תחילו penalty_cost.

התעלמות ממשלוח מובילה לשגיאת אימות כשיש shipment_type_requirements במודל.

מותר להתעלם ממשלוח שמבוצע ב-injected_first_solution_routes או ב-injected_solution_constraint. הפותר מסיר את הביקורים הקשורים לאיסוף/מסירה מהמסלול שפועל. המערכת תתעלם גם מהמשלוחים שהתעלמו מהם precedence_rules.
penalty_cost

double

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

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

double

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

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

start_time(delivery) - start_time(pickup) <=
std::ceil(t * (1.0 + pickup_to_delivery_relative_detour_limit))

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

טען

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

שדות
amount

int64

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

VisitRequest

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

שדות
arrival_location

LatLng

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

Waypoint

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

LatLng

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

Waypoint

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

string

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

TimeWindow

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

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

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

אפשר להגדיר את cost_per_hour_after_soft_end_time ואת soft_end_time רק אם יש חלון זמן אחד.
duration

Duration

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

double

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

map<string, Load>

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

string

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

סוג מסוים יכול להופיע פעם אחת בלבד.
label

string

מציין תווית עבור VisitRequest. התווית מדווחת בתשובה בתור visit_label בShipmentRoute.Visit המתאימה.

ShipmentModel

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

  • העלות של ניתוב כלי הרכב (סכום העלות לזמן כולל, עלות לזמן נסיעה ועלות קבועה של כל כלי הרכב).
  • הסנקציות על משלוח שלא בוצעו.
  • העלות של משך הזמן הגלובלי של המשלוחים
שדות
shipments[]

Shipment

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

Vehicle

קבוצת כלי רכב שניתן להשתמש בהם לצורך ביקור.
global_start_time

Timestamp

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

משך הזמן של המודל צריך להיות קצר משנה. כלומר, global_end_time ו-global_start_time חייבים להיות בטווח של 31536,000 שניות זה מזה.

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

Timestamp

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

double

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

DurationDistanceMatrix

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

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

  • יש שני מיקומים: locA ו-locB.
  • כלי רכב אחד שמתחיל את המסלול ב-locA ומסתיים בו ב-locA.
  • בקשת ביקור אחת לאיסוף ב-locB.
model {
  vehicles { start_tags: "locA"  end_tags: "locA" }
  shipments { pickups { tags: "locB" } }
  duration_distance_matrix_src_tags: "locA"
  duration_distance_matrix_src_tags: "locB"
  duration_distance_matrix_dst_tags: "locA"
  duration_distance_matrix_dst_tags: "locB"
  duration_distance_matrices {
    rows {  # from: locA
      durations { seconds: 0 }   meters: 0    # to: locA
      durations { seconds: 100 } meters: 1000 # to: locB
    }
    rows {  # from: locB
      durations { seconds: 102 } meters: 990 # to: locA
      durations { seconds: 0 }   meters: 0   # to: locB
    }
  }
}
  • יש שלושה מיקומים: locA, locB ו-locC.
  • רכב אחד מתחיל במסלול הנסיעה ב-locA ומסתיים בספרות locB, באמצעות המטריצה 'מהירה'.
  • כלי רכב אחד שמתחיל את המסלול ב-locB ומסתיים בספרות locB, תוך שימוש במטריצת 'slow'.
  • כלי רכב אחד שמתחיל את המסלול ב-locB ומסתיים בספרות locB, תוך שימוש במטריצת 'מהיר'.
  • בקשת ביקור אחת לאיסוף ב-locC.
model {
  vehicles { start_tags: "locA" end_tags: "locB" start_tags: "fast" }
  vehicles { start_tags: "locB" end_tags: "locB" start_tags: "slow" }
  vehicles { start_tags: "locB" end_tags: "locB" start_tags: "fast" }
  shipments { pickups { tags: "locC" } }
  duration_distance_matrix_src_tags: "locA"
  duration_distance_matrix_src_tags: "locB"
  duration_distance_matrix_src_tags: "locC"
  duration_distance_matrix_dst_tags: "locB"
  duration_distance_matrix_dst_tags: "locC"
  duration_distance_matrices {
    vehicle_start_tag: "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
    }
  }
  duration_distance_matrices {
    vehicle_start_tag: "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
    }
  }
}
duration_distance_matrix_src_tags[]

string

תגים המגדירים את המקורות של מטריצות משך הזמן והמרחק; duration_distance_matrices(i).rows(j) מגדיר משכי זמן ומרחקים מביקורים עם התג duration_distance_matrix_src_tags(j) לביקורים אחרים במטריצה i.

התגים תואמים ל-VisitRequest.tags או ל-Vehicle.start_tags. VisitRequest או Vehicle נתונים חייבים להתאים בדיוק לתג אחד בשדה הזה. חשוב לשים לב שתגי המקור, היעד והמטריצה של Vehicle עשויים להיות זהים; בדומה לכך, תג המקור ותגי היעד של VisitRequest עשויים להיות זהים. כל התגים חייבים להיות שונים ואינם יכולים להיות מחרוזות ריקות. אם השדה הזה לא ריק, אסור שהשדה duration_distance_matrices יהיה ריק.
duration_distance_matrix_dst_tags[]

string

תגים המגדירים את היעדים של מטריצות משך הזמן והמרחק; duration_distance_matrices(i).rows(j).durations(k) (מהירות duration_distance_matrices(i).rows(j).meters(k)) מגדיר את משך הזמן (המרחק) של הנסיעה מביקורים עם התג duration_distance_matrix_src_tags(j) לביקורים עם התג duration_distance_matrix_dst_tags(k) במטריצה i.

התגים תואמים ל-VisitRequest.tags או ל-Vehicle.start_tags. VisitRequest או Vehicle נתונים חייבים להתאים בדיוק לתג אחד בשדה הזה. חשוב לשים לב שתגי המקור, היעד והמטריצה של Vehicle עשויים להיות זהים; בדומה לכך, תג המקור ותגי היעד של VisitRequest עשויים להיות זהים. כל התגים חייבים להיות שונים ואינם יכולים להיות מחרוזות ריקות. אם השדה הזה לא ריק, אסור שהשדה duration_distance_matrices יהיה ריק.
transition_attributes[]

TransitionAttributes

תכונות מעבר נוספו למודל.
shipment_type_incompatibilities[]

ShipmentTypeIncompatibility

קבוצות של סוגי משלוח שאינם תואמים (מידע נוסף זמין בקטע ShipmentTypeIncompatibility).
shipment_type_requirements[]

ShipmentTypeRequirement

קבוצות של דרישות shipment_type (ראו ShipmentTypeRequirement).
precedence_rules[]

PrecedenceRule

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

int32

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

DurationDistanceMatrix

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

שדות
rows[]

Row

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

string

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

כל התחלת רכב צריכה להתאים בדיוק למטריצה אחת, כלומר, רק מטריצה אחת מתוך השדה start_tags שלה צריכה להתאים ל-vehicle_start_tag של מטריצה (ושל אותה מטריצה בלבד).

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

שורה

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

שדות
durations[]

Duration

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

double

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

PrecedenceRule

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

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

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

שדות
first_is_delivery

bool

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

bool

מציין אם האירוע ה'שני' הוא מסירה.
offset_duration

Duration

הסטייה בין האירוע ה "ראשון" לאירוע ה "שני". הוא יכול להיות שלילי.
first_index

int32

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

int32

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

ShipmentRoute

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

  |            |            |          |       |  T[2], |        |      |
  | Transition |  Visit #0  |          |       |  V[2], |        |      |
  |     #0     |    aka     |   T[1]   |  V[1] |  ...   | V[n-1] | T[n] |
  |  aka T[0]  |    V[0]    |          |       | V[n-2],|        |      |
  |            |            |          |       | T[n-1] |        |      |
  ^            ^            ^          ^       ^        ^        ^      ^
vehicle    V[0].start   V[0].end     V[1].   V[1].    V[n].    V[n]. vehicle
 start     (arrival)   (departure)   start   end      start    end     end

לידיעתכם, אנחנו מבחינים בין הנתונים הבאים:

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

משתנים:

  • אם יש n ביקורים, יש מעברים של n+1.
  • ביקור מוקף תמיד במעבר לפניו (אותו אינדקס) ובמעבר אחריו (אינדקס + 1).
  • מעבר מס' 0 תמיד מתחיל בהתחלת הרכב.
  • מעבר #n תמיד מופיע לפני סיום הרכב.

בהתקרבות, זה מה שקורה במהלך Transition ו-Visit:

---+-------------------------------------+-----------------------------+-->
   |           TRANSITION[i]             |           VISIT[i]          |
   |                                     |                             |
   |  * TRAVEL: the vehicle moves from   |      PERFORM the visit:     |
   |    VISIT[i-1].departure_location to |                             |
   |    VISIT[i].arrival_location, which |  * Spend some time:         |
   |    takes a given travel duration    |    the "visit duration".    |
   |    and distance                     |                             |
   |                                     |  * Load or unload           |
   |  * BREAKS: the driver may have      |    some quantities from the |
   |    breaks (e.g. lunch break).       |    vehicle: the "demand".   |
   |                                     |                             |
   |  * WAIT: the driver/vehicle does    |                             |
   |    nothing. This can happen for     |                             |
   |    many reasons, for example when   |                             |
   |    the vehicle reaches the next     |                             |
   |    event's destination before the   |                             |
   |    start of its time window         |                             |
   |                                     |                             |
   |  * DELAY: *right before* the next   |                             |
   |    arrival. E.g. the vehicle and/or |                             |
   |    driver spends time unloading.    |                             |
   |                                     |                             |
---+-------------------------------------+-----------------------------+-->
   ^                                     ^                             ^
V[i-1].end                           V[i].start                    V[i].end

לסיום, כך ניתן לארגן את הנסיעות, ההפסקות, ה-Shift וה-WAIT במהלך מעבר.

  • אין חפיפה ביניהן.
  • ה-OAuth הוא ייחודי וחייב להיות פרק זמן מתמשך שממש לפני הביקור הבא (או לפני הסיום של הרכב). לכן מספיק לדעת את משך ההשהיה כדי לדעת מהן שעות ההתחלה והסיום.
  • ה-breakS הם תקופות זמן רציפות שאינן חופפות. התשובה מציינת את שעת ההתחלה ואת משך הזמן של כל הפסקה.
  • נסיעות ו-WAIT הן "מוגדרות מראש": ייתכן שהן יופסקו כמה פעמים במהלך המעבר. הלקוחות יכולים להניח שנסיעה מתבצעת "בהקדם האפשרי" וש "ההמתנה" ממלאת את הזמן שנותר.

דוגמה (מורכבת):

                               TRANSITION[i]
--++-----+-----------------------------------------------------------++-->
  ||     |       |           |       |           |         |         ||
  ||  T  |   B   |     T     |       |     B     |         |    D    ||
  ||  r  |   r   |     r     |   W   |     r     |    W    |    e    ||
  ||  a  |   e   |     a     |   a   |     e     |    a    |    l    ||
  ||  v  |   a   |     v     |   i   |     a     |    i    |    a    ||
  ||  e  |   k   |     e     |   t   |     k     |    t    |    y    ||
  ||  l  |       |     l     |       |           |         |         ||
  ||     |       |           |       |           |         |         ||
--++-----------------------------------------------------------------++-->
שדות
vehicle_index

int32

רכב שמבצע את המסלול, מזוהה לפי האינדקס שלו במקור ShipmentModel.
vehicle_label

string

תווית של כלי הרכב שמבצע את המסלול הזה, שווה ל-ShipmentModel.vehicles(vehicle_index).label, אם צוין.
vehicle_start_time

Timestamp

השעה שבה הרכב מתחיל את המסלול.
vehicle_end_time

Timestamp

השעה שבה הרכב מסיים את המסלול.
visits[]

Visit

רצף ביקורים מסודר שמייצג מסלול. ביקורים[i] הוא הביקור ה-i במסלול. אם השדה הזה ריק, הרכב ייחשב כרכב שלא בשימוש.
transitions[]

Transition

רשימה מסודרת של המעברים במסלול.
has_traffic_infeasibilities

bool

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

  start_time(previous_visit) + duration(previous_visit) +
  travel_duration(previous_visit, next_visit) > start_time(next_visit)

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

EncodedPolyline

ייצוג הקו הפוליגוני המקודד של המסלול. השדה הזה יאוכלס רק אם המדיניות OptimizeToursRequest.populate_polylines מוגדרת כ-True.
breaks[]

Break

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

AggregatedMetrics

מדדים של משך הזמן, המרחק והטעינה במסלול הזה. סיכום השדות של AggregatedMetrics מתבצע בכל ה-ShipmentRoute.transitions או ShipmentRoute.visits, בהתאם להקשר.
route_costs

map<string, double>

עלות המסלול, בחלוקה לפי שדות בקשה הקשורים לעלות. המפתחות הם נתיבים של תבניות אב, ביחס לקלט OptimizeToursRequest, למשל "model.shipments.pickups.cost". הערכים הם העלות הכוללת שנוצרה על ידי שדה העלות המתאים, שנצבר לאורך כל המסלול. במילים אחרות, העלויות ["model.shipments.pickups.cost"] הן הסכום של כל עלויות האיסוף לאורך המסלול. כל העלויות שמוגדרות במודל מדווחות כאן בפירוט, חוץ מהעלויות שקשורות למאפייני מעבר, שמדווחות רק באופן מצטבר החל מ-1 בינואר 2022.
route_total_cost

double

העלות הכוללת של המסלול. סכום כל העלויות במפת העלויות.

הפסקה

נתונים שמייצגים את ביצוע ההפסקה.

שדות
start_time

Timestamp

שעת ההתחלה של ההפסקה.
duration

Duration

משך ההפסקה.

EncodedPolyline

הייצוג המקודד של קו פוליגוני. מידע נוסף על קידוד פוליגונים זמין כאן: https://developers.google.com/maps/documentation/utilities/polylinealgorithm https://developers.google.com/maps/documentation/javascript/reference/geometry#encoding.

שדות
points

string

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

מעבר

מעבר בין שני אירועים במסלול. מידע נוסף מופיע בתיאור של ShipmentRoute.

אם אין לרכב start_location או end_location, מדדי הנסיעה המתאימים הם 0.

שדות
travel_duration

Duration

משך הנסיעה בתקופת המעבר.
travel_distance_meters

double

המרחק שעברת במהלך המעבר.
traffic_info_unavailable

bool

כשיש בקשה לקבלה של תנועת גולשים דרך OptimizeToursRequest.consider_road_traffic ולא ניתן לאחזר את נתוני התנועה של Transition, הערך הבוליאני מוגדר כ-true. מצב זה עשוי להיות זמני (שיבושים נדירים בשרתי התנועה בזמן אמת) או קבוע (אין נתונים לגבי המיקום הזה).
delay_duration

Duration

סך משכי השהייה שחלו על המעבר הזה. אם רלוונטי, ההשהיה תתחיל בדיוק delay_duration שניות לפני האירוע הבא (ביקור או סיום הרכב). TransitionAttributes.delay.
break_duration

Duration

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

Duration

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

Duration

משך הזמן הכולל של המעבר, לנוחותך. הוא שווה ל:

  • הביקור הבא start_time (או vehicle_end_time אם זה המעבר האחרון) – start_time של המעבר הזה;
  • אם ShipmentRoute.has_traffic_infeasibilities מוגדר כ-False, הערך הבא כולל בנוסף: `total_duration = travel_duration +duration_duration
  • break_duration + pending_duration`.
start_time

Timestamp

שעת ההתחלה של המעבר.
route_polyline

EncodedPolyline

ייצוג הקו הפוליגוני המקודד של המסלול שעבר במהלך המעבר. השדה הזה יאוכלס רק אם המדיניות populate_transition_polylines מוגדרת כ-True.
vehicle_loads

map<string, VehicleLoad>

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

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

VehicleLoad

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

שדות
amount

int64

כמות העומס על הרכב, לסוג הנתון. יחידת העומס בדרך כלל מצוינת על ידי סוג. Transition.vehicle_loads.

כניסה

ביקור שבוצע במהלך מסלול. הביקור הזה מתייחס לאיסוף או למשלוח של Shipment.

שדות
shipment_index

int32

אינדקס השדה shipments במקור ShipmentModel.
is_pickup

bool

אם הערך הוא true, הביקור תואם לאיסוף של Shipment. אחרת, זה תואם למשלוח.
visit_request_index

int32

אינדקס של VisitRequest בשדה האיסוף או המשלוח של Shipment (מידע נוסף: is_pickup).
start_time

Timestamp

השעה שבה הביקור מתחיל. חשוב לדעת שהרכב עשוי להגיע מוקדם יותר למיקום הביקור. השעות תואמות לShipmentModel.
load_demands

map<string, Load>

הביקוש הכולל לעומס על הביקורים, כסך המשלוח ובקשת הביקור load_demands. הערכים שליליים אם הביקור הוא מסירה. הדיווח על דרישות מתבצע לגבי אותם סוגים כמו בעמודה Transition.loads (אפשר לעיין בשדה הזה).
detour

Duration

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

start_time(delivery) - start_time(pickup)
- (duration(pickup) + travel duration from the pickup location
to the delivery location).

אחרת, הוא מחושב מהרכב start_location ושווה ל:

start_time - vehicle_start_time - travel duration from
the vehicle's `start_location` to the visit.
shipment_label

string

עותק של Shipment.label המתאים, אם צוין ב-Shipment.
visit_label

string

עותק של VisitRequest.label המתאים, אם צוין ב-VisitRequest.

ShipmentTypeIncompatibility

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

שדות
types[]

string

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

IncompatibilityMode

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

IncompatibilityMode

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

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

לשני משלוחים עם סוגים שאינם תואמים למצב חוסר התאימות של NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY:

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

ShipmentTypeRequirement

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

שדות
required_shipment_type_alternatives[]

string

רשימה של סוגי משלוחים חלופיים שנדרשים על ידי dependent_shipment_types.
dependent_shipment_types[]

string

לכל משלוחים מהסוג הזה בשדה dependent_shipment_types, צריך לבקר לפחות במשלוח אחד מסוג required_shipment_type_alternatives באותו מסלול.

הערה: אסור לפרסם שרשרת של דרישות שתלויות בshipment_type.
requirement_mode

RequirementMode

המצב הוחל על הדרישה.

RequirementMode

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

טיפוסים בני מנייה (enums)
REQUIREMENT_MODE_UNSPECIFIED מצב הדרישה לא צוין. לעולם אין להשתמש בערך הזה.
PERFORMED_BY_SAME_VEHICLE במצב הזה, כל המשלוחים ה "תלויים" חייבים להיות באותו רכב שבו נמצא לפחות אחד מהמשלוחים ה "נדרשים" שלהם.
IN_SAME_VEHICLE_AT_PICKUP_TIME

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

לכן, איסוף משלוח 'תלוי' חייב לכלול:

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

SkippedShipment

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

שדות
index

int32

האינדקס תואם לאינדקס המשלוח במקור ShipmentModel.
label

string

עותק של Shipment.label המתאים, אם צוין ב-Shipment.
reasons[]

Reason

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

סיבה

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

reasons {
  code: DEMAND_EXCEEDS_VEHICLE_CAPACITY
  example_vehicle_index: 1
  example_exceeded_capacity_type: "Apples"
}
reasons {
  code: DEMAND_EXCEEDS_VEHICLE_CAPACITY
  example_vehicle_index: 3
  example_exceeded_capacity_type: "Pears"
}
reasons {
  code: CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DISTANCE_LIMIT
  example_vehicle_index: 1
}

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

שדות
code

Code

יש לעיין בהערות של Code.
example_exceeded_capacity_type

string

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

int32

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

קוד

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

טיפוסים בני מנייה (enums)
CODE_UNSPECIFIED אסור להשתמש באפשרות הזו אף פעם. אם אנחנו לא יכולים להבין למה דילגת על המשלוח, נחזיר קבוצה ריקה של סיבות.
NO_VEHICLE אין במודל רכב שלא מאפשר לבצע את כל המשלוחים.
DEMAND_EXCEEDS_VEHICLE_CAPACITY הביקוש במשלוח חורג מהקיבולת של כלי רכב מסוימים מסוגי הקיבולת, שאחד מהם הוא example_exceeded_capacity_type.
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DISTANCE_LIMIT

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

שימו לב שלחישוב הזה אנחנו משתמשים במרחקים גיאודזיים.
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT

הזמן המינימלי הנדרש לביצוע המשלוח הזה, כולל זמן הנסיעה, זמן ההמתנה וזמן השירות, חורג מ-route_duration_limit של הרכב.

הערה: זמן הנסיעה מחושב במקרה הטוב ביותר, כלומר במרחק גיאודזי x 36 מטרים לשנייה (בסביבות 130 ק"מ לשעה).
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TRAVEL_DURATION_LIMIT כמו למעלה, אבל אנחנו משווים רק בין זמן הנסיעה המינימלי לבין travel_duration_limit של הרכב.
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TIME_WINDOWS הרכב לא יכול לבצע את המשלוח הזה בתרחיש המקרה הטוב ביותר (ראו CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT לחישוב זמן) אם הוא מתחיל בשעת ההתחלה המוקדמת ביותר: הזמן הכולל יגרום לכך שהרכב יסתיים אחרי שעת הסיום האחרונה שלו.
VEHICLE_NOT_ALLOWED השדה allowed_vehicle_indices של המשלוח לא ריק והרכב הזה לא שייך לו.

TimeWindow

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

גבולות של חלון זמן קשה, start_time ו-end_time, אוכפים את השעה המוקדמת ביותר והעדכנית ביותר של האירוע, כך start_time <= event_time <= end_time. הגבול התחתון של חלון הזמן הרך, soft_start_time, מבטא העדפה לכך שהאירוע יתרחש בתאריך soft_start_time או אחריו, כי הוא צובר עלות יחסית למשך הזמן שחולף לפני soft_start_time שהאירוע מתרחש. הגבול העליון של חלון הזמן הרך, soft_end_time, מבטא העדפה לכך שהאירוע יתרחש עד soft_end_time או לפני כן, בכך צבירת עלות ביחס למשך הזמן אחרי soft_end_time שבו האירוע מתרחש. start_time, end_time, soft_start_time ו-soft_end_time צריכים להיות במסגרת מגבלות הזמן הגלובליות (ראו ShipmentModel.global_start_time ו-ShipmentModel.global_end_time) ועליהן לעמוד בדרישות הבאות:

  0 <= `start_time` <= `soft_start_time` <= `end_time` and
  0 <= `start_time` <= `soft_end_time` <= `end_time`.
שדות
start_time

Timestamp

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

Timestamp

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

Timestamp

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

Timestamp

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

double

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

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

העלות הזו חייבת להיות חיובית, ואפשר להגדיר את השדה רק אם הוגדר soft_start_time.
cost_per_hour_after_soft_end_time

double

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

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

העלות הזו חייבת להיות חיובית, ואפשר להגדיר את השדה רק אם הוגדר soft_end_time.

TransitionAttributes

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

שדות
src_tag

string

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

ביקור במקור או התחלת רכב תואמים אם השדה VisitRequest.tags או Vehicle.start_tags שלהם מכיל src_tag או לא מכיל excluded_src_tag (בהתאם לאחד משני השדות האלה אינו ריק).
excluded_src_tag

string

src_tag. השדה src_tag ו-excluded_src_tag לא יכול להיות ריק.
dst_tag

string

ביקור ביעד או ערך סיום כלי רכב תואמים אם השדה VisitRequest.tags או Vehicle.end_tags שלו מכיל dst_tag או לא מכיל excluded_dst_tag (בהתאם לאחד משני השדות האלה אינו ריק).
excluded_dst_tag

string

dst_tag. השדה dst_tag ו-excluded_dst_tag לא יכול להיות ריק.
cost

double

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

double

מציין עלות לקילומטר שחלה על המרחק שעברתם בזמן ביצוע המעבר. הנתון הזה מצטבר לכל Vehicle.cost_per_kilometer שצוין בכלי רכב.
distance_limit

DistanceLimit

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

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

Duration

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

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

כלי רכב

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

שדות
display_name

string

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

TravelMode

מצב הנסיעה שמשפיע על הדרכים שבהן הרכב זמין והמהירות שלו. למידע נוסף, יש לעיין ב-travel_duration_multiple.
start_location

LatLng

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

Waypoint

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

LatLng

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

Waypoint

נקודת ציון שמייצגת מיקום גיאוגרפי שבו הרכב מסתיים אחרי VisitRequest האחרון שלו. אם לא מציינים end_waypoint וגם לא end_location, ערך ShipmentRoute של הרכב יסתיים מיד בסיום פעולת VisitRequest האחרונה. אם מודל המשלוח כולל מטריצות של משך ומרחק, אין לציין end_waypoint.
start_tags[]

string

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

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

string

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

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

TimeWindow

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

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

אפשר להגדיר את cost_per_hour_after_soft_end_time ואת soft_end_time רק אם יש חלון זמן אחד.
end_time_windows[]

TimeWindow

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

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

אפשר להגדיר את cost_per_hour_after_soft_end_time ואת soft_end_time רק אם יש חלון זמן אחד.
unloading_policy

UnloadingPolicy

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

map<string, LoadLimit>

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

double

עלויות הרכב: כל העלויות מצטברות וחייבות להיות באותה יחידה כמו Shipment.penalty_cost.

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

double

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

double

עלות לקילומטר של מסלול הרכב. העלות הזו חלה על המרחק המדווח בShipmentRoute.transitions ולא חלה על מרחק בנסיעה באופן לא מפורש מ-arrival_location ל-departure_location של VisitRequest יחיד.
fixed_cost

double

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

bool

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

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

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

DurationLimit

הגבלה שחלה על משך הזמן הכולל של המסלול של הרכב. בOptimizeToursResponse נתון, משך המסלול של הרכב הוא ההפרש בין vehicle_end_time לבין vehicle_start_time.
travel_duration_limit

DurationLimit

הגבלה שחלה על משך הנסיעה במסלול של הרכב. ב-OptimizeToursResponse נתון, משך הנסיעה במסלול הוא הסכום של כל ה-transitions.travel_duration.
route_distance_limit

DistanceLimit

המגבלה חלה על המרחק הכולל של המסלול של הרכב. בOptimizeToursResponse נתון, המרחק של המסלול הוא הסכום של כל transitions.travel_distance_meters שלו.
extra_visit_duration_for_visit_type

map<string, Duration>

מציין מפה ממחרוזות visit_types למשך הזמן. משך הזמן הוא זמן בנוסף ל-VisitRequest.duration, שייערך בביקורים עם visit_types שצוין. משך הביקור הנוסף הזה מוסיף עלות אם מציינים cost_per_hour. מפתחות (למשל visit_types) לא יכולים להיות מחרוזות ריקות.

אם לבקשת ביקור יש כמה סוגים, יתווסף משך זמן לכל סוג במפה.
break_rule

BreakRule

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

string

מציין תווית לרכב הזה. התווית מדווחת בתשובה בתור vehicle_label של ShipmentRoute התואם.
ignore

bool

אם הערך הוא True, הערך של used_if_route_is_empty חייב להיות False, והרכב הזה יישאר ללא שימוש.

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

אם משלוח מבוצע על ידי רכב של injected_solution_constraint שלא מסתמך על המשלוח, ואיסוף/מסירה שקשור אליו מוגבל להישאר ברכב (כלומר, לא במצב רגוע עד רמה RELAX_ALL_AFTER_THRESHOLD), המערכת תדלג על המשלוח בתשובה. אם המשלוח כולל את השדה allowed_vehicle_indices שאינו ריק והמערכת מתעלמת מכל כלי הרכב המותרים, המערכת תדלג עליו בתשובה.
travel_duration_multiple

double

מציין גורם כפל שאפשר להשתמש בו כדי להגדיל או לקצר את זמני הנסיעה של הרכב הזה. לדוגמה, אם קובעים במדיניות את הערך 2.0, המשמעות היא שהרכב הזה איטי יותר וזמני הנסיעה שלו גדולים פי שניים כשמדובר ברכבים רגילים. הכפולה הזו לא משפיעה על משך הביקורים. אם מציינים cost_per_hour או cost_per_traveled_hour, כן תהיה לכך השפעה על העלות. הערך חייב להיות בטווח [0.001, 1000.0]. אם לא מגדירים את הערך של הרכב, הערך של הרכב הוא 1.0 והכפולה הזו נחשבת כ-1.0.

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

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

DurationLimit

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

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

שדות
max_duration

Duration

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

Duration

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

אם מוגדר, soft_max_duration חייב להיות מספר לא שלילי. אם מוגדר גם max_duration, הערך soft_max_duration חייב להיות קטן מ-max_duration.
quadratic_soft_max_duration

Duration

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

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

max_duration - quadratic_soft_max_duration <= 86400 seconds
cost_per_hour_after_soft_max

double

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

  cost_per_hour_after_soft_max * (duration - soft_max_duration)

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

double

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

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

  cost_per_square_hour_after_quadratic_soft_max *
  (duration - quadratic_soft_max_duration)^2

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

LoadLimit

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

שדות
soft_max_load

int64

גבול "רך" של העומס. cost_per_unit_above_soft_max.
cost_per_unit_above_soft_max

double

אם העומס יחרוג מ-soft_max_load במסלול של הרכב, העונש הבא יחול על העלות (פעם אחת בלבד לכל רכב): (עומס - soft_max_load) * cost_per_unit_above_soft_max. כל העלויות מצטברות יחד באותה יחידה כמו Shipment.penalty_cost.
start_load_interval

Interval

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

Interval

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

int64

כמות הטעינה הקבילה המקסימלית.

מרווח

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

שדות
min

int64

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

int64

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

TravelMode

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

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

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

UnloadingPolicy

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

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

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

נקודת ציון

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

שדות
side_of_road

bool

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

Location

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

string

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