Holarch

SysML v2

הערכה, יחידות וניתוח בפרויקטים של SysML v2

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

אופן השימוש ←

בדף זה
  1. סקירה כללית
  2. מושגים
    1. ערכים עם יחידות
    2. חישוב
    3. הגדרות מחדש מחליפות ערכים שעברו בירושה
    4. נתוני מודל ונתוני Holarch
  3. איך להשתמש בה
    1. מתי ולמה
    2. הצגת ערך מחושב
    3. בדיקת אילוצים בתצוגה פרמטרית
    4. פתרון ערכים
    5. מקרי ניתוח עם נעלמים
    6. סיכום תקציב
    7. מעקב אחר TPM
    8. הרצת ניתוח חלופות
    9. סימולציה של זרימת פעולות
    10. בדיקת סימולציה מול דרישה
    11. דוגמה מעשית: הדגמת Hybrid Car
    12. עצות ושיטות עבודה טובות
    13. טעויות נפוצות
    14. כיצד זה מתחבר לתכונות אחרות
  4. מדריך עיון: תצוגה פרמטרית
    1. מה היא מציגה
    2. סרגל כלים
    3. חלונית ההוספה
    4. תגים ומצבים
  5. תקציבים ו-TPMs בפרויקטים של SysML v2
    1. עץ החלקים
    2. ערכים
    3. הודעות
  6. ניתוחי חלופות בפרויקטים של SysML v2
    1. ניתוחי חלופות במודל
  7. כיצד הסימולטור קורא את המודל
    1. שלבים וסדר
    2. משכי זמן
    3. החלטות ולולאות
    4. הודעות של בדיקה מול דרישה
  8. מגבלות
  9. דפים קשורים

סקירה כללית

פרויקט SysML v2 מחשב עם הערכים שבמודל שלו. ערכי תכונות נושאים יחידות, כמו 1580 [kg] או 72 [kW], ו-Holarch מחשב אותם עם היחידות האלה. דפי הניתוח קוראים את הערכים המחושבים:

היכןמה הוא מחשב
חלונית המאפייניםהערך המחושב של התכונה הנבחרת ("מחושב ל-…").
תצוגה פרמטריתערכי אילוצים, הצלחה או כשל לכל אילוץ, ופתרון הכול / פתרון.
ארכיטקטורה → תקציבים ו-TPMsגודל כמו מסה או הספק המסוכם לאורך עץ החלקים, עם רזרבה, הקצאות ומרווחים; מדדי TPM.
סיכונים, בעיות והחלטות → ניתוחי חלופותציונים משוקללים של חלופות, עם ערכים שנמשכים מהמודל.
התנהגות → סימולטורריצות אירוע בדיד וניתוחי מונטה קרלו של זרימות פעולה, ובדיקה מול דרישה.

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

מושגים

ערכים עם יחידות

שימוש תכונה יכול לקשור ערך: attribute redefines mass = 45 [kg];. הערך הוא ביטוי. הוא יכול להיות מספר עם יחידה, שם של תכונה אחרת, או חשבון כמו capacity / drivePower * cruiseSpeed.

  • היחידות מגיעות מהספרייה הסטנדרטית של SysML v2 (SI::kg, SI::kW, SI::h). יחידות מורכבות נכתבות בסוגריים המרובעים: [kW*h], [W/kg], [km/h].
  • מספר פשוט ללא יחידה הוא מספר.
  • הטיפוס נותן את סוג הגודל: attribute curbMass : MassValue; מצהיר על מסה. כדי להשתמש בשמות האלה ללא קידומת, יש לייבא את ISQ::* ואת SI::*.

חישוב

בודק SysML של Holarch מחשב ביטויים עם המודל:

  • ליטרלים, אופרטורים של חשבון ושל השוואה.
  • חשבון גדלים עם ממדים, והמרה בין יחידות הספרייה (1 [min] הוא 60 [s]).
  • שמות ושרשראות תכונות כמו fleet.sedan.curbMass, דרך הגדרות, התמחויות והגדרות מחדש.
  • הגדרות חישוב שנקראות עם ארגומנטים, וערך האמת של אילוצים.

ערך שמציין תכונה לא ידועה, או שמערבב ממדים שאינם תואמים, אינו מחושב. העורך מסמן בעיות יחידות, כמו "The units do not match: … Convert one side to a compatible unit." (היחידות אינן תואמות.)

הגדרות מחדש מחליפות ערכים שעברו בירושה

חלק יורש את התכונות של ההגדרה שלו ושל ההגדרות שההגדרה הזו מתמחה בהן. הגדרה מחדש מחליפה את הערך שעבר בירושה. בהדגמת Hybrid Car, Component מצהיר על attribute mass : MassValue;, Battery קובע attribute redefines mass = 45 [kg];, והסוללה של הסדאן עצמו קובעת attribute redefines mass = 48 [kg];. לכן הסוללה של הסדאן שוקלת 48 ק״ג; כל סוללה אחרת שוקלת 45 ק״ג.

נתוני מודל ונתוני Holarch

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

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

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

איך להשתמש בה

מתי ולמה

את הדפים האלה משתמשים כשהמבנה והערכים שלו כבר קיימים במודל:

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

כל הארבעה מתחברים לדרישות. ה-require constraint של דרישה נותן קריטריון. אילוצים בתצוגה פרמטרית בודקים ערכים מול מגבלות. בדיקה מול דרישה רושמת את התוצאה במקרה אימות.

הצגת ערך מחושב

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

    מתחת לשדה מופיע "מחושב ל-1580 ק״ג" (או התוצאה המחושבת עבור ביטוי). עבור ערך שמציין אלמנט אחר, מופיע "מפנה אל" והשם המלא של האלמנט.

  3. כדי לשנות את הערך, יש לערוך את השדה וללחוץ על Enter. הבורר שלפניו בוחר = (קושר את הערך) או := (קובע ערך התחלתי).

בדיקת אילוצים בתצוגה פרמטרית

  1. יש לפתוח את הכלי דיאגרמות וללחוץ על + דיאגרמה חדשה.
  2. יש לבחור תצוגה פרמטרית ואת החבילה שהיא מציגה, וללחוץ על יצירה.

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

  3. יש לקרוא את התג על כל אילוץ:
    • הצלחה: האילוץ מתקיים עבור הערכים הקשורים.
    • כשל: האילוץ אינו מתקיים עבור הערכים הקשורים.
    • דורש קלט: לפרמטר עדיין אין ערך. יש לקשור כל פרמטר לערך.
  4. כדי לקשור פרמטר, יש לגרור מהפין שלו אל ערך. הערך של הפרמטר הופך לשם של הערך, כמו in mass = fleet.sedan.curbMass;.
  5. כדי להסיר קשירה, יש לבחור את קו הקשירה וללחוץ על Delete.

פתרון ערכים

  1. בתצוגה פרמטרית, יש ללחוץ על פתרון הכול כדי לפתור כל אילוץ בתצוגה. כדי לפתור אחד, יש לבחור את האילוץ (או אחד מהפרמטרים שלו) וללחוץ על פתרון.

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

  2. יש ללחוץ על החלת N שינויים.

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

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

מקרי ניתוח עם נעלמים

מקרה ניתוח יכול להשאיר ערכים שהמטרה שלו תקבע. תכונה של המקרה ללא ערך היא נעלם, ומשוואות ה-== של אילוצי ה-require של המטרה שלו (והאילוצים שבבעלות המקרה) נפתרות עבור הנעלמים האלה, יחד היכן שהן חולקות אותם. לאחר מכן תוצאת ה-return של המקרה מחושבת עם הערכים שנפתרו.

analysis def BatterySizingAnalysis {
  subject car : Car;
  in attribute electricRange : LengthValue;
  in attribute cruiseSpeed : SpeedValue;
  in attribute specificEnergy;
  attribute drivePower : PowerValue;
  attribute capacity : EnergyValue;
  attribute totalMass : MassValue;
  objective sizing {
    require constraint powerNeeded { drivePower == 0.012 * totalMass * 9.81 [m/s^2] * cruiseSpeed + 3 [kW] }
    require constraint energyNeeded { capacity == drivePower * electricRange / cruiseSpeed }
    require constraint massWithBattery { totalMass == car.curbMass + capacity / specificEnergy }
  }
  return packCapacity : EnergyValue = capacity;
}

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

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

סיכום תקציב

  1. יש לפתוח את ארכיטקטורה → תקציבים ו-TPMs.
  2. יש ללחוץ על בחירת חלק שורש… ולבחור שימוש חלק או הגדרת חלק.
  3. תחת גודל, יש להזין את שם התכונה. מסה קורא את mass, הספק קורא את power, צריכת הספק קורא את powerDraw. הרשימה מציעה את השמות של תכונות שיש להן ערכים.

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

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

    Holarch כותב אותו כ-48 [kg] היכן שהתכונה מוצהרת. אם החלק רק יורש את התכונה, Holarch מוסיף לחלק תכונה שמגדירה אותה מחדש.

  6. כדי לשנות את מספר העותקים של חלק, יש להקליד בעמודה ספירה. היא קובעת את הריבוי של החלק.
  7. יש ללחוץ על ייצוא XLSX כדי לייצא את התקציב.

מעקב אחר TPM

  1. יש לפתוח את הכרטיסייה מדדי TPM של תקציבים ו-TPMs.
  2. יש לבחור Measure עם התווית TPM. ההערכה הנוכחית, הסף, היעד, הפרופיל המתוכנן וההיסטוריה שלו מוצגים כמו בפרויקטים של LML.
  3. כדי לקשר Measure לחלקים שהוא מודד, יש לפתוח אותו ולהשתמש ב-קישור פריט קיים… בקטע עקיבות שלו.

פריטי Measure הם פריטי Holarch, לא אלמנטי מודל.

הרצת ניתוח חלופות

  1. יש לפתוח את סיכונים, בעיות והחלטות → ניתוחי חלופות וללחוץ על + ניתוח חלופות חדש.
  2. תחת חלופות, יש ללחוץ על + קיים… כדי להוסיף הגדרות חלק או שימושי חלק מהמודל, כמו הגדרות חלק של גרסאות. + חדש יוצר הגדרת חלק ואת החלק שלה.
  3. יש להוסיף קריטריונים עם + קריטריון, ולתת לכל אחד שם לפי התכונה שהוא קורא: הקריטריון Top Speed קורא את topSpeed.
  4. יש ללחוץ על משיכת ערכים מהמודל.

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

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

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

סימולציה של זרימת פעולות

  1. יש לפתוח תצוגת זרימת פעולות ולבחור ▶ סימולציה ▾ → אירוע בדיד או מונטה קרלו. או לפתוח את התנהגות → סימולטור ולבחור את פעולת השורש: הגדרת פעולה או שימוש פעולה עם פעולות משלה.
  2. יש להגדיר את הגדרות הסימולטור: החלטות, מהירות, שינוי משכים קבועים ו-± %, זרע אקראי, תאריכי לוח שנה והתחלה במצב מושהה (שלב אחר שלב) עבור אירוע בדיד; ריצות עבור מונטה קרלו. הן נשמרות עם פעולת השורש.
  3. יש ללחוץ על ▶ הפעלה, ⏭ צעד או ⏩ הרצה עד הסוף (אירוע בדיד), או להריץ את ניתוח מונטה קרלו.

    ציר הזמן מציג כל שלב בזמן שהוא רץ. זרימת Action בזמן הריצה מדגיש את השלבים בתצוגת זרימת הפעולות שמציגה את הפעולה.

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

בדיקת סימולציה מול דרישה

  1. יש לכתוב את הקריטריון כ-require constraint של דרישה בטקסט, למשל require constraint { tripTime <= 120 [s] }.
  2. יש להריץ ניתוח מונטה קרלו, ואז ללחוץ על בדיקה מול דרישה… ולבחור את הדרישה.

    Holarch לוקח את הקריטריון מה-require constraint. המודל מחשב את המגבלה (120 שניות) ובודק את האילוץ בממוצע של הריצות.

  3. יש ללחוץ על תיעוד התוצאה…. הפעולה קובעת את המצב והתוצאה של מקרה אימות שמאמת את הדרישה, או יוצרת אחד, וביטול פעולה אחד מחזיר הכול לאחור.

דוגמה מעשית: הדגמת Hybrid Car

קודם יש ליצור את ההדגמה: בניהול פרויקטים, יש ללחוץ על קובצי פרויקט ▾ → פרויקט הדגמה חדש → Hybrid Car (SysML v2).

אילוצים. יש לפתוח את הכלי דיאגרמות ולפתוח את התצוגה sedanParametrics. היא מציגה שני אילוצים מהחבילה VehicleViews:

constraint sedanMassCheck : MassLimit {
  in mass = fleet.sedan.curbMass;
  in limit = maxCurbMass;
}

MassLimit קובע mass <= limit. המסה העצמית של הסדאן היא 1580 ק״ג ו-maxCurbMass הוא 1650 ק״ג, ולכן sedanMassCheck מציג הצלחה. sedanBatteryCheck משווה את הקיבולת של סוללת הסדאן, 1.4 קוט״ש, ל-minBatteryCapacity, 1.2 קוט״ש, וגם הוא עובר.

  1. בעורך, יש לפתוח את Vehicles ולשנות את attribute redefines curbMass = 1580 [kg]; של הסדאן ל-1700 [kg].
  2. יש לחזור ל-sedanParametrics.

    sedanMassCheck מציג עכשיו כשל. ביטול השינוי עם ⌘Z / Ctrl+Z.

תקציב. יש לפתוח את ארכיטקטורה → תקציבים ו-TPMs. בהדגמה, הסדאן (fleet.sedan) הוא השורש ומסה הוא הגודל.

  • העץ מציג את המרכב, את המכל, המנוע, המנוע החשמלי, הסוללה, תיבת ההילוכים והבקר של מערכת ההנעה, ואת שני הסרנים עם הדיפרנציאל ושני הגלגלים של כל אחד. גלגל החילוף נספר כ-1, הגבול העליון של [0..1].
  • הסוללה מציגה 48 ק״ג, ההגדרה מחדש של הסדאן עצמו, ולא 45 ק״ג של Battery.
  • לסדאן יש הקצאה של 1650 ק״ג ולמערכת ההנעה 360 ק״ג; הבסיס של המנוע הוא מחושב ושל הסוללה נמדד.
  • יש להעביר את גודל להספק כדי לראות את תקציב העומס החשמלי, עם הקצאה של 2000 W.

בכרטיסייה מדדי TPM, Sedan Curb Mass (TPM-1) ו-Sedan Electrical Load (TPM-2) מציגים את הפרופילים המתוכננים ואת ההיסטוריה שלהם.

ניתוח חלופות. יש לפתוח את סיכונים, בעיות והחלטות → ניתוחי חלופות ולבחור Launch Variant Selection (TR-1). החלופות שלו הן הגדרות החלק SportCar ו-CityCar.

  • Top Speed מגיע מתכונות ה-topSpeed שלהן: 210 קמ״ש ו-160 קמ״ש.
  • ל-Mass אין תכונה בשם הזה בגרסאות, ולכן הוא הסיכום של החלקים שלהן. CityCar קל יותר כי המרכב שלו מגדיר מחדש mass = 780 [kg].
  • Purchase Price ו-Driving Fun הוזנו ידנית. ההחלטה שתועדה בחרה ב-CityCar.

סימולציה. יש לפתוח את התצוגה driveCycleFlow (DriveCycle ב-VehicleBehavior) ולבחור ▶ סימולציה ▾ → מונטה קרלו.

  • כל שלב לוקח את תכונת ה-duration שלו: supply 3 שניות ו-produce 4 שניות במקביל, accelerate 12 שניות, cruise דקה אחת, brake 8 שניות, ו-drive 75 שניות לצידם.
  • ההחלטה shift מגינה על cruise עם speed > 30. המודל אינו יכול לחשב את speed לפני הריצה, ולכן ההדגמה קובעת את הסתברויות ההסתעפות על הרצפים: cruise 70%, else 30%.
  • הגדרות הניתוח של ההדגמה הן 200 ריצות, שונות אחידה של ±10% במשכים הקבועים, וזרע 42.

עצות ושיטות עבודה טובות

  • יש לתת יחידה לכל ערך. 48 [kg] מסוכם, מומר ונבדק. 48 חשוף על MassValue מסומן כבעיה: "Add a unit, for example 5 [kg]." (יש להוסיף יחידה.)
  • יש להצהיר על תכונה פעם אחת בהגדרה כללית (Component::mass) ולהגדיר מחדש את הערך שלה בכל התמחות. תקציבים וניתוחי חלופות מוצאים אותה אז לפי שם בכל מקום.
  • יש לתת לקריטריונים של ניתוח חלופות שמות לפי תכונות ("Top Speed" עבור topSpeed), כדי שמשיכת ערכים מהמודל תמלא אותם.
  • יש לשמור מגבלות של דרישות כתכונות בעלות שם (maxCurbMass) ולקשור אליהן אילוצים. עריכה אחת מעדכנת אז כל בדיקה.
  • בתצוגה גדולה, כדאי להשתמש בפתרון על אילוץ אחד לפני פתרון הכול, כדי לסקור את השינויים בקבוצות קטנות.

טעויות נפוצות

  • אילוץ מציג «דורש קלט». לפרמטר אין ערך קשור, או שלערך שהוא מציין אין ערך. יש לגרור מהפין של הפרמטר אל ערך, או לתת לערך מספר.
  • התקציב אינו מציג ערכים. ההודעה היא "אין חלק תחת <root> עם ערך עבור <quantity>. יש להזין ערכים בעמודה ערך ליחידה, או לתת להגדרות החלק תכונה <name> עם ערך." יש לבדוק את שם התכונה: צריכת הספק קורא את powerDraw, לא את power_draw.
  • בשורת תקציב מופיעה אזהרה במקום ערך. הערך של התכונה אינו מחושב למספר עם יחידות, למשל כי הוא מציין תכונה שאינה קיימת. יש לתקן את הערך בעורך.
  • «פתרון הכול» אינו משנה ערך. הערך הוא ביטוי, לא מספר. פתרון כותב רק מספרים או ערכים ריקים.
  • «בדיקה מול דרישה» אינה מוצאת קריטריון. הדרישה צריכה require constraint שמשווה ערך לא ידוע אחד למגבלה ידועה, כמו tripTime <= 120 [s].

כיצד זה מתחבר לתכונות אחרות

  • דרישות: ה-require constraint של דרישה נותן את הקריטריון לבדיקה מול דרישה. כשערך או אילוץ שדרישה מציינת משתנים, הקישורים שלה מסומנים לבדיקה (ראו דרישות ואימות בפרויקטים של SysML v2).
  • אימות: תיעוד התוצאה… קובע את המצב והתוצאה של מקרה אימות; ה-RVTM מציג אותם.
  • תצוגות: התצוגה הפרמטרית ותצוגת זרימת הפעולות הן תצוגות של המודל (ראו תצוגות SysML v2).
  • מסמכים: ערכים חיים מציגים ערכי תכונות עם היחידות שלהם, כמו 1650 [kg].
  • החלטות: תיעוד ההחלטה… יוצר את ההחלטה בדף ההחלטות.

מדריך עיון: תצוגה פרמטרית

התצוגה הפרמטרית היא General View עם המסנן @SysML::ConstraintDefinition or @SysML::ConstraintUsage. היא משורטטת כמו Parametric Diagram של LML.

מה היא מציגה

  • אילוצים: כל שימוש אילוץ עם הביטוי שלו (שלו עצמו, או של ההגדרה שלו) והשם שלו.
  • פרמטרים: פינים על הקצה התחתון של האילוץ, עם תווית של השם והערך שלהם. פרמטרי in, out ו-in-and-out מסומנים.
  • ערכים קשורים: ערך שפרמטר מציין. הוא מופיע בתוך החלק שלו כשהוא שייך לחלק, או לבדו עבור ערך ברמת החבילה כמו maxCurbMass.
  • קווי קשירה: מכל פרמטר אל הערך שהוא קשור אליו.

סרגל כלים

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

חלונית ההוספה

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

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

תגים ומצבים

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

תקציבים ו-TPMs בפרויקטים של SysML v2

הדף הוא דף תקציבים ו-TPMs של LML; לכל פקד, אריח ועמודה ראו תקציבים ו-TPMs. בפרויקט SysML v2 הוא שונה כך:

עץ החלקים

  • שורש: שימוש חלק או הגדרת חלק, שנבחרים עם בחירת חלק שורש….
  • שורות: שימושי החלק של החלק עצמו, ואחריהם החלקים שההגדרות שלו מביאות (typed by, specializes) והחלקים של התכונות שהוא מגדיר מחדש. חלק שמגדיר מחדש חלק שעבר בירושה מחליף אותו, כך ש-part redefines battery { … } נספר פעם אחת, עם הערכים שלו.
  • ספירה: הריבוי של החלק. [2] נספר כ-2, טווח כמו [0..1] נספר לפי הגבול העליון שלו, ו-[0] אינו נספר כלל. ללא ריבוי, חלק שמגדיר מחדש לוקח את הריבוי של החלק שהוא מגדיר מחדש; אחרת הוא נספר כ-1.

ערכים

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

הודעות

הודעהמשמעות ותיקון
לא נבחר חלק שורש. יש להשתמש ב«בחירת חלק שורש…» כדי לבחור את החלק או הגדרת החלק לתקצוב.יש לבחור שורש.
אין חלק תחת <root> עם ערך עבור "<quantity>". …לאף תכונה בשם הזה אין ערך. יש להזין ערכים, או להוסיף את התכונה להגדרות החלק.
"<text>" אינו מספר עם יחידות. יש להזין ערך כמו 12 kg.לא ניתן היה לקרוא את הערך ליחידה שהוקלד.
"<value>" אינו מחושב למספר עם יחידות.הערך של התכונה במודל אינו מספר עם יחידות. יש לתקן אותו בטקסט.

ניתוחי חלופות בפרויקטים של SysML v2

הדף הוא דף ניתוחי חלופות של LML; ראו סיכונים, בעיות והחלטות. בפרויקט SysML v2:

  • הניתוח, ההחלטה שלו והקריטריונים שלו (פריטי Measure) הם פריטי Holarch.
  • + קיים… מציג את הגדרות החלק ושימושי החלק של המודל, ואת פריטי Holarch. + חדש מבקש שם ויוצר הגדרת חלק ואת החלק שלה.
  • משיכת ערכים מהמודל ממלא כל תא מהתכונה של החלופה בשם של הקריטריון, מחושבת על ידי המודל ומומרת ליחידות של הקריטריון. כשאין תכונה כזו, הוא לוקח את הסיכום (ההערכה הטובה ביותר הנוכחית) של אותו גודל על פני החלקים של החלופה.
  • משקלים, שיטות ניקוד, מטריצת Pugh, ניתוח רגישות ותיעוד ההחלטה… פועלים כמו בפרויקטים של LML.

ניתוחי חלופות במודל

ניתוח חלופות יכול גם להיות חלק מהמודל עצמו, עם הספרייה הסטנדרטית TradeStudies:

analysis batteryTradeStudy : TradeStudies::TradeStudy {
  subject :>> studyAlternatives : Battery = (nmcPack, lfpPack, nimhPack);
  calc :>> evaluationFunction {
    in part :>> alternative : Battery;
    return attribute :>> result = alternative.capacity / alternative.mass / (1 [W*h/kg]);
  }
  objective :>> tradeStudyObjective : TradeStudies::MaximizeObjective;
}

Holarch מנקד כל חלופה בעזרת פונקציית ההערכה ובוחר את זו עם הציון הגבוה ביותר (MaximizeObjective) או הנמוך ביותר (MinimizeObjective); בציונים שווים, החלופה הראשונה זוכה. הבחירה היא התוצאה של הניתוח, selectedAlternative. יש לבחור את הניתוח בדפדפן: תוצאת המקרה בחלונית המאפיינים מציגה את החלופות עם הציונים שלהן ומסמנת את זו שנבחרה. כשאי אפשר לחשב ציון (ערך שהוא קורא חסר), שום דבר אינו נבחר והמצב הוא לא שלם. ה-batteryTradeStudy של הדגמת Hybrid Car מנקד שלושה מארזי סוללות לפי אנרגיה לקילוגרם ובוחר את nmcPack.

כיצד הסימולטור קורא את המודל

הסימולטור הוא הסימולטור של LML; לדף, ללוחות שלו ולסטטיסטיקה של מונטה קרלו ראו סימולציה. בפרויקט SysML v2 הוא קורא את המודל כך:

שלבים וסדר

מודלסימולציה
שימוש פעולה (גם שלבי accept, send וחישוב)שלב.
רצף (first a then b;, then b;)סדר השלבים.
פיצול ואיחוד, כמה רצפים שיוצאים משלב אחד, או כמה שלבים ראשוניםענפים מקבילים שרצים עד האיחוד.
החלטה (decide), או רצפים מותניםנלקח ענף אחד.
לולאות while ו-for, או רצף חזרה לשלב מוקדם יותרהשלבים חוזרים.
פעולת ifהגוף שלה רץ או שמדלגים עליו.
השמה (assign speed := 0;)שינוי ערך. הוא אינו לוקח זמן.
perform (ו-allocate)החלק המבצע הוא המבצע של השלב. הכרטיסייה Resources מציגה עד כמה כל חלק עסוק.
זרימת רצףהיעד ממתין לפריט. זרימות אחרות אינן גורמות לו להמתין.

משכי זמן

שלב לוקח את הזמן של התכונה duration שלו, או של תכונה מטיפוס DurationValue או TimeValue, שלו או של ההגדרה שלו: attribute duration : DurationValue = 5 [s];.

סימון התפלגות מהספרייה HolarchSimulation על אותה תכונה גורם לסימולטור להגריל את משך הזמן, למשל @HolarchSimulation::Triangular { low = 45 [s]; mode = 1 [min]; high = 2 [min]; } (ראו מטא-נתוני סימולציה בפרויקטים של SysML v2).

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

  • "במודל: <value> (התכונה duration). שינוי כאן נכתב למודל."
  • "במודל: התכונה duration עם @HolarchSimulation::<distribution> (הסימולטור מגריל אותה)."
  • "אין משך זמן במודל. אפשר לקבוע אותו כאן (נכתב attribute duration : ISQ::DurationValue), או לכתוב אותו בטקסט."
  • עבור פעולה עם זרימה משלה: "השלבים שלה לוקחים את הזמן: מדומה דרך הזרימה שלה."

החלטות ולולאות

תנאי שמירה, תנאי if ותנאי לולאה שהמודל יכול לחשב מחליטים בעצמם. חלונית המאפיינים מציגה אז "מחושב כ-true: נלקח תמיד." או "מחושב כ-false: לא נלקח אף פעם."

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

רכיבהגדרה
החלטההסתברות (%) לכל ענף יוצא. ענפים ללא הסתברות חולקים את השאר שווה בשווה.
רצףהסתברות (%): אחרי החלטה, באיזו תדירות הענף הזה נלקח; בחזרה לשלב מוקדם יותר, באיזו תדירות השלבים חוזרים.
לולאהאיטרציות: כמה פעמים הסימולטור מריץ את גוף הלולאה כשהמודל אינו יכול לחשב את התנאי.
פעולת ifהסתברות של then (%).

ההגדרות האלה נכתבות למודל כמטא-נתונים של HolarchSimulation (Probability, LoopCount), וביטול פעולה אחד מבטל כל אחת מהן. פרויקטים עם הגדרות ישנות יותר שנשמרו לצד המודל שומרים אותן עד שהעברת הגדרות הסימולציה למודל… בסימולטור מעביר אותן פנימה; ראו מטא-נתוני סימולציה בפרויקטים של SysML v2. כשהסתברויות ההסתעפות של החלטה אינן מסתכמות ב-100%, האזהרה היא "הסתברויות ההסתעפות מסתכמות ב-N%. יש לשנות אותן כך שיסתכמו ב-100%."

הודעות של בדיקה מול דרישה

הודעהתיקון
לדרישה אין require constraint. יש לכתוב אחד בטקסט, למשל require constraint { tripTime <= 120 [s] }.יש להוסיף require constraint, או להזין את הסף ידנית.
אין require constraint שמשווה ערך לא ידוע אחד למגבלה ידועה (למשל tripTime <= 120 [s]). יש להזין את הסף.האילוץ חייב להשוות ערך אחד שהמודל אינו יכול לחשב למגבלה שהוא יכול לחשב.
בודק SysML לא הצליח לחשב את האילוץ: … יש להזין את הסף.יש להזין את הסף ידנית.

מגבלות

  • מכונות מצבים, גירויים, משאבים ועלויות ממטא-נתונים רצים רק עם מנוע SysML; הסימולטור מציג מנוע SysML או סימולטור JavaScript ליד ההגדרות שלו. ראו סימולציה של מכונת מצבים.
  • פתרון הכול כותב רק ערכים מילוליים (מספרים, עם יחידות או בלעדיהן). ערכים שנכתבו כביטויים אינם נדרסים.
  • גאומטריה תלת-ממדית אינה משורטטת ואינה מחושבת.

SysML® ו-OMG® הם סימנים מסחריים רשומים של Object Management Group, Inc. בארצות הברית ובמדינות אחרות.