Holarch

מדריך · SysML v2

כלי SysML v2: מה לבדוק לפני שבוחרים

האזנה למדריך 16 דק׳

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

בדף זה
  1. למה כלי SysML v2 צריכים הערכה משלהם
  2. מה לבדוק
    1. כיסוי השפה, ואיך פערים מתועדים
    2. סימון טקסטואלי: עריכה ובדיקה
    3. תצוגות גרפיות, וסנכרון בין טקסט לדיאגרמה
    4. ספרייה סטנדרטית
    5. ה-Systems Modeling API
    6. החלפה ב-JSON והלוך ושוב
    7. הגירה מ-SysML v1
    8. שיתוף פעולה ובקרת גרסאות
    9. דרישות ואימות על המודל
    10. ניתוח וחישוב עם יחידות
    11. פריסה: בענן או באירוח עצמי
    12. רישוי ועלות
    13. הדרכה
  3. רשימת תיוג להערכה
  4. מודל בדיקה לטעינה בכל מועמד
    1. שתי בדיקות לבודק
  5. ביצוע ההערכה
  6. התשובות של Holarch לרשימת התיוג
  7. לנסות ב-Holarch
  8. לאן ממשיכים

למה כלי SysML v2 צריכים הערכה משלהם

SysML v2 היא שפה חדשה, לא מהדורה מתוקנת של SysML v1 (במה SysML v1 ו-v2 נבדלות משווה ביניהן בפירוט). יש לה סימון טקסטואלי וגם גרפי, בסיס סמנטי פורמלי ב-KerML, ספרייה סטנדרטית של גדלים, יחידות וסוגי תצוגות, ו-API סטנדרטי לקריאה וכתיבה של מודלים. כלי יכול לטעון לתמיכה ב-SysML v2 ועדיין לכסות רק חלק מזה, והחלקים שהוא משמיט עשויים להיות אלה שהתוכנית שלכם תלויה בהם.

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

כדי למצוא מועמדים, אפשר להתחיל מרשימת כלי ה-SysML v2 שה-OMG מתחזק ומסיכום יכולות כלי SysML v2 ש-INCOSE וה-OMG פרסמו כדי לתמוך במעבר מ-SysML v1. שניהם נקודות התחלה: יש לקרוא אותם בשביל השמות, ואז לבדוק כל כלי בעצמכם.

מה לבדוק

כיסוי השפה, ואיך פערים מתועדים

יש לבקש הצהרת כיסוי: כל תחום של השפה (packages, הגדרות ו-usages, הכללה והגדרה מחדש, ריבויים, ערכים ויחידות, אילוצים, מבנה, פעולות, מצבים, דרישות, use cases, מקרי ניתוח ואימות, views, מטא-נתונים, שונות, individuals ו-time slices) עם רמה לכל אחד. רמות שימושיות מבחינות בין ארבעה מקרים:

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

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

סימון טקסטואלי: עריכה ובדיקה

הסימון הטקסטואלי הוא המקום שבו SysML v2 שונה ביותר מ-v1, וגם המקום שבו הכלים שונים זה מזה יותר מכול. יש לבדוק:

  • עריכה: צביעת תחביר, השלמה של שמות ומילות מפתח, מעבר להגדרה, שינוי שם בכל המודל, חיפוש והחלפה.
  • בדיקה תוך כדי הקלדה: שגיאות תחביר הן המינימום. בודק שימושי גם פותר כל שם דרך ה-imports, מדווח על שמות כפולים ודו-משמעיים, בודק הגדרות מחדש מול מה שעובר בירושה, משווה ממדי יחידות, ומשווה כיווני ports ו-flows לאורך חיבורים.
  • הטקסט הוא המודל: אחרי עריכה, האם כל תצוגה אחרת רואה את השינוי, או שהטקסט הוא קובץ שהכלי מייבא מפעם לפעם?
  • טקסט שהכלי לא כתב: יש לטעון טקסט שנכתב ביד או בכלי אחר. הערות, תיעוד ופריסת הטקסט צריכים להישמר.

תצוגות גרפיות, וסנכרון בין טקסט לדיאגרמה

ב-SysML v2 ה-view הוא רכיב מודל: הוא מציין מה הוא חושף ומסנן, והכלי מציג אותו. הספרייה הסטנדרטית מגדירה views מסוג General, ‏Interconnection, ‏Action Flow, ‏State Transition, ‏Sequence ו-Grid. יש לבדוק אילו מהם הכלי מצייר, באילו אפשר לערוך, ואיך הוא מטפל בפריסה, שהמפרט משאיר לכלי.

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

ספרייה סטנדרטית

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

ה-Systems Modeling API

ה-Systems Modeling API הוא ממשק ה-REST הסטנדרטי למאגר מודלים: פרויקטים, ענפים, commits ורכיבים. הוא מאפשר לכלים להחליף מודלים בלי קבצים, ומאפשר לסקריפטים שלכם לקרוא מודלים. כלי יכול למלא שני תפקידים, וכל אחד מהם יכול להיות לקריאה בלבד:

  • לקוח: הכלי מושך ממאגר אחר שמציע את ה-API ודוחף אליו.
  • שרת: הכלי מציע את ה-API כדי שכלים אחרים יקראו, ואולי גם יכתבו, את המודלים שלו.

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

החלפה ב-JSON והלוך ושוב

מלבד הטקסט, מודלים עוברים בין כלים כ-SysML v2 JSON: פורמט הרכיבים של ה-API, עם מזהה לכל רכיב. למזהים יש חשיבות: הטקסט אינו נושא אותם, ולכן כלי שמייבא טקסט מחדש יכול להתאים רכיבים רק לפי שם, ואילו JSON שומר על הזהות לאורך ההחלפה. יש לבדוק מעבר הלוך ושוב: ייצוא מכלי A, ייבוא לכלי B, ייצוא חוזר וייבוא ל-A. אחר כך יש להשוות את מספר הרכיבים, השמות, הערכים עם היחידות והקשרים, ולקרוא איך כל כלי מדווח על מה שהשמיט. סוגי רכיבים שכלי אינו תומך בהם הם המקום שבו מעברים הלוך ושוב מאבדים נתונים.

הגירה מ-SysML v1

אין תרגום אוטומטי ללא אובדן מ-v1 ל-v2: השפות שונות במבנה שלהן, ודיאגרמות v1 נושאות פריסה ו-stereotypes שאין להם מקבילה אחת ב-v2. יש לשאול איך הכלי מכניס מודלים של v1 (בדרך כלל XMI עם פרופיל SysML 1.x), למה הוא ממפה blocks, ‏parts, ‏ports, ‏activities, ‏state machines ודרישות, והאם הוא מפיק דוח על מה שלא הומר. יש לנסות זאת על אחד ממודלי ה-v1 שלכם, לא על הדוגמה של הספק.

שיתוף פעולה ובקרת גרסאות

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

דרישות ואימות על המודל

SysML v2 הופכת דרישה לאילוץ על subject, עם קשרי satisfy ו-verify לתכן ולמקרי האימות. יש לבדוק שהכלי שומר את טקסט הדרישה ואת האילוץ יחד, מחשב את האילוץ מול ערכי המודל, ובונה מטריצת אימות מקישורי ה-verify. יש לבדוק גם מה הכלי שומר מחוץ לשפה: סטטוס דרישה, אישורים, תוצאות בדיקה וקישורים חשודים אחרי שינוי. אלה אינם חלק מטקסט SysML v2, ולכן יש לשאול היכן הם נשמרים והאם הם עוברים עם ייצוא.

ניתוח וחישוב עם יחידות

כל ערך במודל SysML v2 יכול לשאת יחידה, וביטויים משלבים אותן. יש לבדוק שהכלי מחשב ביטויים עם יחידות (מסה כוללת משלוש מסות של parts, בקילוגרמים), מדווח על טעות ממדים כשגיאה, ומחשב את אילוצי הדרישות מול התוצאה. אחר כך יש לבדוק את יכולות הניתוח הרחבות יותר שנדרשות לכם: פתרון פרמטרי, תקציבים וצבירות, ניתוחי חלופות, סימולציה של action flows או state machines. יש לשאול מה מחושב מתוך המודל ומה דורש נתונים נוספים שייחודיים לכלי.

פריסה: בענן או באירוח עצמי

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

רישוי ועלות

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

הדרכה

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

רשימת תיוג להערכה

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

תחוםהשאלה שיש לשאולאיך לבדוק
כיסוי השפההאם יש טבלת כיסוי מפורסמת עם פערים ידועים?יש למצוא בה את המבנים שהמודלים שלכם משתמשים בהם; לטעון את מודל הבדיקה
סימון טקסטואליהאם העורך בודק שמות, הגדרות מחדש, יחידות וכיוונים תוך כדי הקלדה?יש לטעון את שני הגששים; כל אחד צריך לדווח על בעיה אחת
תצוגות גרפיותאילו תצוגות סטנדרטיות מצוירות וניתנות לעריכה?יש לפתוח Interconnection View ו-State Transition View של מודל הבדיקה
סנכרון טקסט ודיאגרמההאם שינוי בכל אחד מהצדדים מופיע מיד בצד השני?יש לשנות את השם של controller בטקסט; להוסיף חיבור בדיאגרמה ולקרוא את הטקסט
ספרייה סטנדרטיתהאם גדלי ISQ, יחידות SI ותצוגות סטנדרטיות נפתרים?מודל הבדיקה מייבא את ISQ, SI ו-StandardViewDefinitions
Systems Modeling APIלקוח, שרת או שניהם? קריאה בלבד או קריאה וכתיבה?יש לקרוא את רכיבי מודל הבדיקה מכלי אחר או בסקריפט
מעבר JSON הלוך ושובהאם מזהי הרכיבים נשמרים? מה מושמט, והאם יש על כך דיווח?ייצוא, ייבוא לכלי שני, ייצוא חוזר, השוואה
הגירה מ-v1האם יש מסלול ייבוא מ-SysML v1, עם דוח?יש להמיר אחד ממודלי ה-v1 שלכם
שיתוף פעולהעריכה בו-זמנית, תפקידים, קווי בסיס, השוואה?שני אנשים עורכים את אותו package; השוואה מול קו בסיס
דרישות ואימותהאם אילוצים מחושבים ונבנית מטריצת אימות?יש להוריד את מגבלת המסה ל-20 kg ולראות שהדרישה נכשלת
ניתוח עם יחידותהאם ערכים מחושבים עם יחידות? מה עוד מחושב?יש לבדוק ש-totalMass מחושב ל-23 kg
פריסהמתארח, שולחני, באירוח עצמי?יש לבקש את האפשרויות בכתב, עם מיקום הנתונים
רישוי ועלותעלות כוללת לכותבים, לסוקרים ולצופים; ייצוא בכל תוכנית?יש לתמחר את הצוות שלכם, כולל הסוקרים
הדרכהעיון בשפה, דוגמאות, מדריכים לכלי?משתמש חדש ממדל את מערכת הבדיקה מתוך התיעוד בלבד

מודל בדיקה לטעינה בכל מועמד

המודל הזה קטן מספיק כדי להקליד אותו, ועדיין נוגע ברוב מה שהערכה צריכה: imports מהספרייה הסטנדרטית, הגדרות ו-usages של parts עם ערכים ויחידות שהוגדרו מחדש, ports מצומדים, חיבורים ו-binding, ‏state machine, ‏action עם successions, שתי דרישות עם אילוצים, satisfy, מקרה אימות ושני views. יש לשמור אותו כ-pump-station.sysml ולטעון אותו לכל כלי.

המערכת היא משאבת מים סולארית: פאנל מזין בקר, והבקר מפעיל את המשאבה. היחידה חייבת לשקול לא יותר מ-25 kg, וההספק המרבי של הפאנל חייב לעלות על ההספק הנקוב של המשאבה ב-20 % לפחות. אם הסימון חדש לכם, המדריך ל-SysML v2 מציג כל מבנה שהמודל הזה משתמש בו.

package PumpStation {
  doc /* A solar-powered water pump: a small probe model for evaluating SysML v2 tools. */

  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;

  port def PowerPort {
    out attribute voltage : ElectricPotentialValue;
  }

  port def WaterPort {
    out attribute pressure : PressureValue;
  }

  part def SolarPanel {
    attribute mass : MassValue;
    attribute peakPower : PowerValue;
    port powerOut : PowerPort;
  }

  part def Controller {
    attribute mass : MassValue;
    port powerIn : ~PowerPort;
    port motorOut : PowerPort;
  }

  part def Pump {
    attribute mass : MassValue;
    attribute ratedPower : PowerValue;
    port powerIn : ~PowerPort;
    port outlet : WaterPort;
  }

  item def StartSignal;
  item def StopSignal;

  state def PumpModes {
    entry; then idle;
    state idle;
    state pumping;
    transition first idle accept StartSignal then pumping;
    transition first pumping accept StopSignal then idle;
  }

  action def DeliverWater {
    action convertSunlight;
    action regulatePower;
    action driveImpeller;
    first start then convertSunlight;
    first convertSunlight then regulatePower;
    first regulatePower then driveImpeller;
    first driveImpeller then done;
  }

  part def PumpUnit {
    part panel : SolarPanel {
      attribute redefines mass = 12 [kg];
      attribute redefines peakPower = 400 [W];
    }
    part controller : Controller {
      attribute redefines mass = 2 [kg];
    }
    part pump : Pump {
      attribute redefines mass = 9 [kg];
      attribute redefines ratedPower = 300 [W];
    }
    port outlet : WaterPort;

    connect panel.powerOut to controller.powerIn;
    connect controller.motorOut to pump.powerIn;
    bind outlet = pump.outlet;

    attribute totalMass : MassValue = panel.mass + controller.mass + pump.mass;
    exhibit state modes : PumpModes;
  }

  part pumpUnit : PumpUnit {
    perform action delivery : DeliverWater;
  }
}

package PumpRequirements {
  private import PumpStation::*;
  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;

  requirement def <'PS-1'> MassLimit {
    doc /* The pump unit shall weigh no more than the mass limit, so that one person can carry it. */
    subject unit : PumpUnit;
    attribute limit : MassValue;
    require constraint { unit.totalMass <= limit }
  }

  requirement def <'PS-2'> PowerMargin {
    doc /* The panel's peak power shall exceed the pump's rated power by at least 20 %. */
    subject unit : PumpUnit;
    require constraint { unit.panel.peakPower >= 1.2 * unit.pump.ratedPower }
  }

  requirement pumpSpec {
    subject unit : PumpUnit;
    requirement mass : MassLimit {
      attribute redefines limit = 25 [kg];
    }
    requirement power : PowerMargin;
  }

  satisfy pumpSpec by pumpUnit;

  verification def <'VC-1'> WeighUnit {
    doc /* Weigh the assembled pump unit on a calibrated scale. */
    subject unit : PumpUnit;
    objective {
      verify pumpSpec.mass;
    }
    return verdict : Boolean = unit.totalMass <= pumpSpec.mass.limit;
  }
}

package PumpViews {
  private import PumpStation::*;
  private import StandardViewDefinitions::*;

  view unitConnections : InterconnectionView {
    expose PumpStation::PumpUnit;
  }

  view pumpStates : StateTransitionView {
    expose PumpStation::PumpModes;
  }
}

מה שכלי שתומך במבנים האלה צריך להציג:

  • אין שגיאות ואין אזהרות. כלי שמדווח כאן על בעיות חסר מבנה מסוים או קורא את הספרייה הסטנדרטית אחרת; יש לשאול מה מהשניים.
  • totalMass מחושב ל-23 kg: ‏12 kg + 2 kg + 9 kg.
  • שתי הדרישות מתקיימות: 23 kg נמצא בתוך 25 kg, ו-400 W הם יותר מ-1.2 × 300 W = 360 W.
  • unitConnections מצייר את הפאנל, הבקר והמשאבה עם ה-ports שלהם, את שני החיבורים ואת היציאה שקשורה לגבול היחידה.
  • pumpStates מצייר שני מצבים עם מעבר התחלתי ושני מעברים מופעלים.
  • מטריצת אימות מציגה את PS-1 כמאומת על ידי VC-1, ואת PS-2 בלי מקרה אימות.

שתי בדיקות לבודק

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

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

package UnitProbe {
  private import ISQ::*;
  private import SI::*;

  part def Pump {
    attribute ratedPower : PowerValue;
  }

  part pump : Pump {
    attribute redefines ratedPower = 300 [kg];
  }
}

השני מנותח ונפתר ללא בעיות, אבל הדרישה שלו אינה מתקיימת: היחידה שוקלת 11 kg מול מגבלה של 10 kg. כלי שמחשב אילוצי דרישות מדווח על כך; כלי שרק מנתח מקבל זאת בשקט.

package RequirementProbe {
  private import ISQ::*;
  private import SI::*;

  part def Pump {
    attribute mass : MassValue;
  }

  part def Unit {
    part pump : Pump {
      attribute redefines mass = 9 [kg];
    }
    attribute totalMass : MassValue = pump.mass + 2 [kg];
  }

  requirement def Light {
    subject unit : Unit;
    require constraint { unit.totalMass <= 10 [kg] }
  }

  part unit : Unit;
  requirement light : Light;
  satisfy light by unit;
}

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

ביצוע ההערכה

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

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

התשובות של Holarch לרשימת התיוג

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

תחוםרמהHolarch היום
כיסוי השפהחלקיטבלה מפורסמת של כל תחום עם הרמה, המגבלות והפערים הידועים שלו. שונות, individuals ו-time slices, מילות מפתח שהמשתמש מגדיר ומטא-נתונים סמנטיים נבדקים ומחושבים; קובצי .kerml עדיין אינם מיובאים; ייצוגים טקסטואליים ב-SysML וב-KerML נבדקים, ושפות אחרות נשמרות כטקסט. כיסוי שפת SysML v2
סימון טקסטואלינתמךעורך שבודק תוך כדי הקלדה (תחביר, שמות, טיפוסים, ריבויים, יחידות, כיוונים, חישוב), עם השלמה, מעבר להגדרה, שינוי שם וחיפוש והחלפה. העורך, בדיקות
תצוגות גרפיותחלקיתצוגות General, ‏Interconnection, ‏Action Flow, ‏State Transition, ‏Sequence ו-Grid, כולן ניתנות לעריכה. Sequence Views מציירות הודעות בין lifelines ו-combined fragments ‏(alt, ‏opt, ‏loop ו-par). תצוגות SysML v2
סנכרון טקסט ודיאגרמהנתמךמודל אחד מאחורי הטקסט וכל תצוגה; עריכה בכל צד מופיעה בצד השני. הטקסט והתצוגות נשארים מסונכרנים
ספרייה סטנדרטיתנתמךטעונה ולקריאה בלבד, עם ISQ, ‏SI, יחידות אמריקאיות מקובלות והגדרות התצוגה הסטנדרטיות. הספרייה הסטנדרטית
Systems Modeling APIחלקיכלקוח: משיכה מענף אחד של מאגר שמציע את ה-API ודחיפה אליו. כשרת: כלים אחרים קוראים את המודל הנוכחי ומבצעים commit לענפי בקשות שינוי, שמאשר מחיל ב-Holarch. משיכה ודחיפה, Systems Modeling API
מעבר JSON הלוך ושובחלקיייבוא וייצוא של SysML v2 JSON עם שמירת מזהי הרכיבים. סוגי רכיבים ש-Holarch אינו מפרש נשמרים כפי שיובאו ונכתבים בחזרה ללא שינוי בייצוא. החלפת מודלים של SysML v2
הגירה מ-v1חלקיייבוא ישיר של מודל SysML 1.x ‏(.mdzip של Cameo או MagicDraw, או XMI מ-Cameo, ‏Enterprise Architect, ‏Rhapsody או Papyrus) לפרויקט SysML v2, עם המרה לטקסט SysML v2 ובדיקה, ודוח על מה שהומר, הוערך בקירוב או הושמט ומדוע. דיאגרמות והפריסה שלהן אינן מומרות. ייבוא מודלים של SysML v1
שיתוף פעולהנתמךעריכה חיה עם מיזוג member אחר member בעורך, תפקידים, קווי בסיס שמחזיקים את המודל, והשוואה לפי רכיב ולפי טקסט ה-package. שיתוף פעולה, קווי בסיס
דרישות ואימותנתמךאילוצי דרישות שמחושבים מול המודל, RVTM ומרכז הבדיקות שנבנים מקישורי verify, אישורים, TBD/TBR וקישורים לסקירה. דרישות ואימות
ניתוח עם יחידותחלקיחישוב עם יחידות, Parametric Views שפותרות נעלם אחד לכל אילוץ, תקציבים, ניתוחי חלופות, וסימולציה של action flows ו-state machines. מקרה ניתוח מחושב רק כשלכל קלט יש ערך. חישוב, יחידות וניתוח
פריסהנתמךאפליקציית אינטרנט מתארחת, ופריסות באירוח עצמי בסביבה שלכם לפי בקשה. אבטחה, יצירת קשר
רישוי ועלותנתמךתוכנית Free לסטודנטים, למרצים, לפרויקטים אישיים ולהערכה אישית; חברות יכולות לנסות את תוכנית Individual בחינם למשך חודש; תוכניות בתשלום לשימוש מסחרי; סוקרים וצופים בחינם בכל תוכנית. מחירים
הדרכהחלקיעיון ב-Docs לכל עמוד של SysML v2, מדריך צעד אחר צעד, ההדגמה Hybrid Car, תשעה מדריכי SysML v2 מודרכים בתוך האפליקציה וסדרת מדריכי וידאו ל-SysML v2 שבונה את מודל Hybrid Car. מסלולי ההדרכה בווידאו מכסים פרויקטים של LML. תחילת העבודה, מדריכי SysML v2, המדריך ל-SysML v2

לנסות ב-Holarch

  1. יש לשמור את מודל הבדיקה כ-pump-station.sysml.
  2. יש לפתוח את מודל ← ייבוא וייצוא, לבחור לפרויקט SysML v2 חדש ולשחרר את הקובץ. ראו ייבוא קבצים לפרויקט חדש.
  3. יש לפתוח את מודל ← עורך. שורת המצב מציגה “אין בעיות”, וכל package הוא מסמך.
  4. יש לפתוח את הרשימה דיאגרמות וללחוץ על unitConnections או על pumpStates.
  5. יש לפתוח את אימות ← RVTM כדי לראות את הדרישות עם המקרה שמאמת אותן.
מודל הבדיקה בעורך, ללא בעיות.
ה-view ‏unitConnections: ports מצומדים, שני חיבורים ו-binding.
ה-RVTM, שנבנה מקישור ה-verify של המודל.

לאן ממשיכים