Holarch

SysML v2

הסימון הטקסטואלי של SysML v2

שפת SysML v2 כפי ש-Holarch תומך בה, עם דוגמאות מהדגמת Hybrid Car, הבדיקות שהיא מריצה והספרייה הסטנדרטית לקריאה בלבד.

אופן השימוש ←

בדף זה
  1. סקירה כללית
  2. מושגים
    1. אלמנטים, בעלים ושמות מלאים
    2. חבילות
    3. ייבואים ונראות
    4. הגדרות ושימושים
    5. טיפוס, התמחות והגדרה מחדש
    6. ריבויים
    7. ערכים ויחידות
    8. מבנה: יציאות, חיבורים, ממשקים, קשירות וזרימות
    9. התנהגות: פעולות
    10. התנהגות: מצבים
    11. דרישות, אילוצים ואימות
    12. מקרי שימוש
    13. תצוגות
    14. הערות, תיעוד ומטא-נתונים
    15. מופעים, תמונות מצב ופרוסות זמן
    16. וריאציות, גרסאות ותצורות
    17. ייצוגים טקסטואליים
  3. איך להשתמש בה
    1. מידול מבנה
    2. מתן ערכים עם יחידות
    3. תיאור התנהגות
    4. כתיבת דרישה ועקיבה אחריה
    5. סימון ערך כ-TBD או כ-TBR
    6. מציאת שם בספרייה
  4. דוגמה מעשית: קריאת הדרישה של הסדאן
  5. טיפים וטעויות נפוצות
  6. במה Holarch תומך
    1. נשמר כפי שנכתב, לא מפורש
    2. עדיין לא זמין
  7. בדיקות
  8. הספרייה הסטנדרטית
  9. מגבלות
  10. דפים קשורים

סקירה כללית

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

הדף הזה מלמד את הסימון בעזרת דוגמאות מהדגמת Hybrid Car (SysML v2). לאחר מכן הוא מפרט מה Holarch תומך בו, את הבדיקות שהוא מריץ על הטקסט, ואת הספרייה הסטנדרטית.

מושגים

אלמנטים, בעלים ושמות מלאים

לכל אלמנט יש בעלים אחד, מלבד החבילות ברמה העליונה. השם המלא של אלמנט הוא שרשרת השמות של הבעלים שלו, מחוברים ב-::. בהדגמה, הסוללה של הגדרת מערכת ההנעה היא Vehicles::Powertrain::battery.

שם עם רווחים או תווים מיוחדים אחרים נכתב במירכאות בודדות: 'Fuel Tank'. שם קצר בסוגריים זוויתיים נותן לאלמנט מזהה שני וקצר: requirement def <'VR-1'> CurbMass. Holarch משתמש בשם הקצר של דרישה כמספר שלה.

חבילות

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

package Vehicles {
    doc /* A hybrid passenger car: structure, interfaces and variants. */

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

ייבואים ונראות

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

  • import ISQ::*; מייבא את החברים של ISQ.
  • import VehicleRequirements::**; מייבא גם את החברים של אלמנטים מקוננים (רקורסיבי).
  • import Vehicles::Car; מייבא אלמנט אחד.
  • import Vehicles::*[@SysML::PartDefinition]; מייבא רק את החברים מסוג אחד (ייבוא מסונן).

private, protected ו-public קובעים מי עוד רואה חבר או ייבוא. ההדגמה כותבת private import כדי שהייבואים לא יעברו הלאה לחבילות שמייבאות אותה בתורן.

בלי ייבוא, יש לכתוב את השם המלא: ISQ::MassValue מזוהה בכל מקום, ו-MassValue רק היכן ש-ISQ מיובא.

alias נותן לאלמנט שם שני: alias Hybrid for Car;.

הגדרות ושימושים

הגדרה מתארת סוג של דבר. שימוש הוא שימוש אחד בהגדרה בתוך אלמנט אחר. לרוב מילות המפתח יש את שתי הצורות:

הגדרהשימושמה זה
part def Battery;part battery : Battery;מערכת, תת-מערכת או רכיב
attribute def TirePressure;attribute mass : MassValue = 45 [kg];ערך, לרוב עם יחידות
item def Fuel;item fuel : Fuel;משהו שזורם או מטופל
port def FuelPort { … }port fuelOut : FuelPort;נקודת חיבור בחלק
connection def … / interface def FuelLine { … }interface fuel : FuelLine connect …;קישור בין חלקים או יציאות
action def ProduceTorque { … }action produce : ProduceTorque;התנהגות: שלב שמקבל קלטים ונותן פלטים
state def PowertrainStates { … }state off;התנהגות: מצב והמעברים שלו
constraint def MassLimit { … }constraint …;תנאי בוליאני על ערכים
calc def PowerToWeight { … }calc …;חישוב עם ערך return
requirement def <'VR-1'> CurbMass { … }requirement <'VR-1.1'> sedanMass : CurbMass;דרישה
use case def DriveToWork { … }use case commute : DriveToWork;מקרה שימוש
analysis def PowerToWeightAnalysis { … }analysis sedanPowerToWeight : …;מקרה ניתוח
verification def CurbMassTest { … }verification sedanWeighing : CurbMassTest;מקרה אימות
view def RequirementsView { … }view driveCycleFlow : ActionFlowView { … }תצוגה של המודל
enum def DriveMode { … }attribute mode : DriveMode;קבוצה קבועה של ערכים

חברים המקוננים בהגדרה שייכים לכל שימוש בה. ל-part frontAxle : Axle; יש את differential, leftWheel ו-rightWheel של Axle בלי לחזור עליהם.

טיפוס, התמחות והגדרה מחדש

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

אופרטורמילת מפתחמשמעותדוגמה
:defined byמגדיר את הטיפוס של שימוש לפי הגדרהpart engine : Engine;
:> על הגדרהspecializesההגדרה היא סוג של ההגדרה האחרת ויורשת את החברים שלהpart def FuelTank :> Component
:> על שימושsubsetsהשימוש הוא תת-קבוצה של שימוש אחרpart spareWheel :> wheels;
:>>redefinesמחליף שימוש שעבר בירושה, למשל כדי לתת לו ערךattribute redefines mass = 18 [kg];
~הופך יציאה: התכונות in ו-out שלה מתחלפותport fuelIn : ~FuelPort;

הגדרה מחדש היא הדרך שבה גרסה או חלק בתצורה משנים את מה שהם יורשים. בהדגמה, SportCar מסיר את גלגל החילוף בהגדרה מחדש:

part def SportCar :> Car {
    attribute topSpeed : SpeedValue = 210 [km/h];
    part redefines spare [0];
}

abstract מסמן הגדרה שאין לה מופעים ישירים (abstract part def Component). ref מסמן הפניה שאינה בבעלות. in, out ו-inout קובעים את הכיוון של תכונה או פרמטר. end מסמן את הקצוות של הגדרת חיבור או ממשק.

ריבויים

ריבוי בסוגריים מרובעים אומר כמה יש.

  • [2]: בדיוק שניים. part runabout : CityCar [2];
  • [0..1]: אופציונלי. part spare : Wheel [0..1];
  • [1..*] ו-[*]: אחד או יותר, כל מספר.
  • [0]: אף אחד, משמש להסרת חלק שעבר בירושה.
  • גבולות יכולים להיות ביטויים. ordered ו-nonunique באים אחרי הסוגריים.

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

= קושר ערך. := נותן ערך התחלתי שיכול להשתנות. default נותן ברירת מחדל שהגדרה מחדש יכולה להחליף.

attribute maxCurbMass : MassValue = 1650 [kg];
attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];
attribute minPowerToWeight = 40 [W/kg];
attribute topSpeed : SpeedValue = 210 [km/h];

גודל הוא מספר עם יחידה בסוגריים מרובעים. יחידות משתלבות עם *, / ו-^ ([m/s^2]). סוגי גדלים כמו MassValue מגיעים מ-ISQ, ויחידות כמו kg מ-SI (או USCustomaryUnits). Holarch בודק ממדים: השמה של 5 [s] ל-MassValue היא שגיאה.

ביטויים משתמשים בחשבון, בהשוואה (<=, ==), באופרטורים לוגיים (and, or, not, implies), בתנאי if c ? a else b, בשרשראות תכונות (car.powertrain.battery.capacity), בקריאות לחישובים (PowerToWeight(power, mass)) ובפעולות על רצפים כמו ->sum, ->size, ->select ו-->collect. Holarch מחשב אותם עם יחידות עבור ערכים, אילוצים, תצוגות ודפי ניתוח.

מבנה: יציאות, חיבורים, ממשקים, קשירות וזרימות

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

part def Powertrain {
    part tank : FuelTank;
    part engine : Engine;
    interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;
    connect controller.engineCtl to engine.ecu;
    port output : TorquePort;
    bind output = transmission.output;
}
  • connect a to b; מחבר שני חלקים או יציאות.
  • ממשק הוא חיבור בעל טיפוס בין יציאות. ההגדרה שלו מציינת את הקצוות שלו: interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  • לכל קצה של חיבור או ממשק יכולים להיות שם וריבוי: interface motorShaft : Shaft connect [1] driver ::> motor.output to [1] driven ::> transmission.motorIn;. קצה בעל שם הוא תכונה של החיבור, ולכן motorShaft.driver מפנה אליו.
  • bind a = b; קובע ששתי תכונות הן אותה תכונה (מחבר קשירה).
  • flow of Fuel from supply.fuel to produce.fuel; מעביר פריט מתכונה אחת לאחרת. message שולח פריט בין חלקים כאירוע.

התנהגות: פעולות

הגדרת פעולה מכילה את השלבים שלה (שימושי פעולה), את הפרמטרים שלה ואת סדר השלבים.

action def DriveCycle {
    in attribute targetSpeed : Real;
    first start then switchOn;
    action switchOn { attribute duration : DurationValue = 2 [s]; }
    then fork split;
    then supply;
    then produce;
    action supply : SupplyFuel;
    action produce : ProduceTorque;
    flow of Fuel from supply.fuel to produce.fuel;
    first supply then ready;
    first produce then ready;
    join ready;
}
  • רצפים קובעים את סדר השלבים: first a then b;, או then b; מיד אחרי a. start ו-done הם ההתחלה והסוף.
  • צמתי בקרה: fork ו-join למסלולים מקבילים; decide ו-merge לחלופות. רצף מותנה אחרי החלטה נכתב if speed > 30 then cruise;, ו-else brake; הוא ענף ברירת המחדל.
  • סיום: terminate; מסיים מיד את הפעולה המקיפה, יחד עם כל השלבים שלה שעדיין רצים; then terminate; ממקם אותו אחרי השלב הקודם. terminate x; מסיים את המופע x.
  • פעולות אחרות: accept ממתין לאות, send שולח אות, assign x := expr; משנה ערך, if מריץ בלוק או מדלג עליו, ו-while … { … } until …; ו-for v in seq { … } חוזרים על בלוק.
  • הקצאת התנהגות: חלק מבצע (perform) פעולה (perform action trip : DriveCycle;, perform trip.supply;), ו-allocate a to b; מקצה אלמנט אחד לאחר.

התנהגות: מצבים

הגדרת מצב מכילה מצבים ואת המעברים ביניהם.

state def PowertrainStates {
    entry; then off;
    state off;
    accept StartRequest then hybrid;
    state hybrid {
        entry action startEngine;
        do action driveHybrid;
        exit action stopEngine;
    }
    transition recharged first hybrid if charge > 60 then electric;
}
  • entry; then off; קובע את המצב ההתחלתי.
  • למעברים יש טריגר (accept StartRequest), תנאי שמירה אופציונלי (if charge > 20) והשפעה אופציונלית (do …). הצורה הקצרה באה אחרי מצב המקור; הצורה הארוכה היא transition name first a … then b;.
  • במודל, הטריגר וההשפעה של מעבר הם אלמנטים בפני עצמם: פעולת קבלה ופעולה (send, assign, perform, terminate או פעולה בעלת שם). הדפדפן מציג אותם כ-trigger וכ-effect מתחת למעבר. הם ה-accepter וה-effect של המעבר עצמו, ולכן חלקים אחרים של המודל יכולים לציין אותם בשמם: chargerStates.plugIn.effect.sentMessage היא ההודעה שההשפעה שולחת, כפי שמודל רצף קושר אותה.
  • טריגר דרך יציאה חייב לקבל משהו שהיציאה נושאת: ב-ChargeManager של ההדגמה, accept connectCharger : ChargerConnected via chargePort תואם את in connected : ChargerConnected של היציאה. ההשפעה send new ChargeRequest() to controller שולחת לחלק; ערך כמו תכונה אינו יכול לקבל הודעה.
  • פעולות entry, do ו-exit רצות בכניסה למצב, בזמן השהייה בו וביציאה ממנו. למצבים מסוג parallel יש אזורים שכולם פעילים בו-זמנית.
  • חלק מציג (exhibit) מצב: exhibit state powertrainStates : PowertrainStates;.

דרישות, אילוצים ואימות

דרישה מכילה את ההצהרה שלה ב-doc, את האלמנט שהיא חלה עליו כ-subject, ותנאי שאפשר לבדוק כ-require constraint.

requirement def <'VR-1'> CurbMass {
    doc /* The car's curb mass shall not exceed the mass limit. */
    subject car : Car;
    attribute limit : MassValue;
    require constraint { car.curbMass <= limit }
}

satisfy carSpec by fleet.sedan;
  • assume constraint מציין תנאי שהדרישה מניחה. כשהוא אינו מתקיים, הדרישה הזו והדרישות המקוננות בה נחשבות כמתקיימות; הדרישה שמקיפה אותה והדרישות המקוננות האחרות עדיין נבדקות. actor, stakeholder ו-frame concern מציינים בשביל מי ובשביל מה הדרישה.
  • satisfy R by part; קובע שחלק עומד בדרישה.
  • מקרה אימות מאמת דרישות במטרה שלו: objective { verify carSpec.sedanMass; }. הוא יכול להחזיר return verdict : Boolean = …;.
  • למקרה ניתוח יש נושא, מטרה ותוצאת return ש-Holarch מחשב כשלכל קלט יש ערך. תכונות של המקרה ללא ערך נפתרות מתוך משוואות == של המטרה שלו (מקרי ניתוח עם נעלמים).
  • connection : Derivation connect original to derived; רושם דרישה נגזרת. #refinement dependency x to R; רושם עידון.
  • dependency from a to b; רושם עקיבה כללית.

מקרי שימוש

use case def DriveToWork { subject car : Car; actor driver : Driver; objective { … } include use case startCar : StartCar; }. שימוש במקרה שימוש לוקח את הנושא ואת השחקנים של ההגדרה שלו.

תצוגות

תצוגה מציגה חלק מהמודל. הטיפוס שלה הוא הגדרת תצוגה סטנדרטית, והיא חושפת (expose) את מה שהיא מציגה:

view driveCycleFlow : StandardViewDefinitions::ActionFlowView {
    expose DriveCycle;
}

filter מצמצם את האלמנטים (filter @SysML::RequirementUsage;). render בוחר אופן הצגה. viewpoint מגדיר את החששות שתצוגה חייבת לטפל בהם. תצוגות SysML v2 מסביר כל סוג תצוגה.

הערות, תיעוד ומטא-נתונים

  • doc /* text */ מתעד את הבעלים שלו. הוא חלק מהמודל; עבור דרישה, הוא טקסט הדרישה.
  • comment about x /* text */ הוא הערה במודל על אלמנט אחר.
  • // text ו-//* text */ הן הערות בטקסט בלבד. Holarch שומר אותן בטקסט, אבל הן אינן אלמנטים של המודל.
  • מטא-נתונים מסמנים אלמנט: @TBD { owner = "Powertrain lead"; } בגוף, #TBR attribute limit … כקידומת, או metadata Capability about Vehicles::Car; מבחוץ.
  • מילות מפתח שהמשתמש מגדיר: כל הגדרת מטא-נתונים פועלת כמילת מפתח: #safetyCritical part controller : Controller; מסמן את הבקר במטא-נתונים SafetyCritical (שם קצר <safetyCritical>). הגדרת מטא-נתונים יכולה להגביל את מה שהיא מסמנת: :>> annotatedElement : SysML::PartDefinition; מתיר רק הגדרות חלק.
  • מטא-נתונים סמנטיים: הגדרת מטא-נתונים שמתמחה ב-SemanticMetadata קובעת טיפוס בסיס, :>> baseType = faults meta SysML::Usage;. כל אלמנט שהיא מסמנת מתמחה אז בבסיס: שימוש הוא תת-קבוצה של שימוש בסיס, והגדרה מתמחה בהגדרת בסיס או בהגדרות של שימוש בסיס. כך #fault def BatteryOverheat; ו-#fault overheat : BatteryOverheat; הם תקלות ויש להם את התכונות של Fault. עם מטא-נתונים סמנטיים אפשר להשמיט את מילת המפתח של השפה, כמו בשתי השורות האלה; הדפדפן מציג אותם עם מילת המפתח שלהם (#fault def). כשכותבים מבחוץ, metadata Fault about x; אינו הופך את x לתקלה: הבדיקה מזהירה ומציעה לסמן את x עצמו ב-#fault.
  • מטא-נתונים עם משמעות משלהם: התכונות של הגדרת מטא-נתונים הן מה שכל שימוש בה חייב לציין, והאילוצים שלה חייבים להתקיים עבורן. עם metadata def SafetyRating { attribute level : Natural; assert constraint { level >= 1 and level <= 4 } }, הבדיקה מדווחת על @SafetyRating; (ללא רמה) ועל @SafetyRating { level = 7; } (מחוץ לטווח); @SafetyRating { level = 4; } תקין. אפשר להשמיט תכונה שיש לה ערך או default בהגדרה, או שהוצהרה כ-[0..1]. כל ערך חייב להתאים לטיפוס של התכונה שלו: true או false עבור Boolean, טקסט במירכאות עבור String, מספר שלם עבור Integer (0 ומעלה עבור Natural, מעל 0 עבור Positive), ועבור מנייה אחד מהערכים שלה, כמו HazardAnalysis::fmea; הבדיקה מדווחת על כל ערך אחר, ועל ברירת מחדל בהגדרה שאינה מתאימה. גוף מטא-נתונים רק נותן ערכים לתכונות של ההגדרה (level = 4;), ואי אפשר להחיל abstract metadata def. הדגמת Hybrid Car מדרגת את הבקר שלה @SafetyRating { level = 4; } ורושמת את הסקירה של הסוללה כ-@SafetyReview { method = HazardAnalysis::fmea; closed = true; }. בעורך, הוספה ▾ → הגדרת מטא-נתונים מתחיל הגדרה עם תכונה וכלל, ו-החלת מטא-נתונים מחיל אחת בתוך גוף. בלי לכתוב טקסט: יש לבחור הגדרה או שימוש ולהשתמש בקטע מטא-נתונים בחלונית המאפיינים. הוספת מטא-נתונים מחיל אחת מהגדרות המטא-נתונים של הפרויקט; לכל תכונה יש אז שדה (רשימת ערכים עבור מנייה או Boolean, טקסט רגיל עבור String, ש-Holarch כותב במירכאות; ברירת המחדל של ההגדרה מוצגת כרמז, ותכונה בלי ברירת מחדל מסומנת כחובה); ממצאי הבדיקה עבור אותם מטא-נתונים מוצגים מתחתיהם; הסרה מסיר אותם. אפשר לבטל כל שינוי בביטול פעולה אחד. מטא-נתונים מהספרייה הסטנדרטית ומהספריות של Holarch עצמו (סימולציה, מטרות, שונות) שומרים על הפקדים שלהם ואינם מופיעים שם.

מופעים, תמונות מצב ופרוסות זמן

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

individual part def Car_VIN1234 :> Car {
    snapshot atDelivery { attribute :>> mileage = 0 [km]; }
    timeslice firstOwner { attribute ownerName : String = "Dana Reyes"; }
    snapshot atService { attribute :>> mileage = 15000 [km]; }
    first atDelivery then atService;
    assert constraint mileageGrows { atDelivery.mileage <= atService.mileage }
}
  • individual בא לפני מילת המפתח של הסוג (individual part def, individual item def) או עומד לבדו (individual def Plate_77;). הטיפוס של שימוש שנכתב כ-individual הוא בדיוק הגדרת יחיד אחת: individual car1 : Car_VIN1234;.
  • snapshot ו-timeslice באים לפני מילת מפתח של סוג או עומדים לבדם, בתוך חלק, פריט, פעולה או מופע אחר. then timeslice secondOwner; ממקם פרוסת זמן אחרי החבר שלפניה.
  • ערך בתוך צילום מצב או פרוסת זמן נקרא שם קודם, אחר כך מהיחיד, ואחר כך מההגדרה שלו. בדוגמה, atService.mileage הוא 15,000 ק״מ והאילוץ מתקיים.
  • רק מופעים יכולים להיות יחידים, צילומי מצב או פרוסות זמן: תכונות ומניות הן ערכים.
  • ב-ארכיטקטורה → חלקים, בתצוגות מסד הנתונים ו-Grid, העמודה מופעים מציגה את היחידים של ההגדרה של כל חלק (עבור part sedan : Car: Car_VIN1234): הגדרות יחיד שמתמחות בה ושימושי יחיד שהיא קובעת את הטיפוס שלהם. גם יחיד (כן) ו-מקטע (צילום מצב או פרוסת זמן) הן עמודות (עמודות ▾ → SysML v2). דף החלקים מציג את מופעים כברירת מחדל ברגע שיש במודל יחיד, וייצוא טבלה (CSV) כולל אז את שלוש העמודות; ייצוא הגדרות מציג אותן לכל אלמנט שיש לו אותן.
  • בחלונית המאפיינים, מופע תחת תכונות קובע יחיד ועבור שימושים גם כל החיים, פרוסת זמן או צילום מצב. במסנן הסוגים של הדפדפן יש יחידים, ובתפריט ⋯ של שורה יש תמונת מצב חדשה… ופרוסת זמן חדשה…. ה-General View מציג «individual part def», «snapshot» ו-«timeslice» בכותרות התיבות, מציג את צילומי המצב ופרוסות הזמן של תיבה בתא משלהם, ומשרטט רצפים בין תיבות כחצים מקווקווים; סידור ▾ → סידור כציר זמן מסדר אותם בשורה משמאל לימין. בהדגמת Hybrid Car, ה-General View carLifeline מציג את צילומי המצב ואת פרוסת הזמן של Car_VIN1234.

וריאציות, גרסאות ותצורות

וריאציה מפרטת את הבחירות המותרות בנקודה אחת של תכן; כל בחירה היא גרסה. הגדרת וריאציה (variation part def) היא קבוצת בחירות לשימוש חוזר; שימוש וריאציה (variation part charger) הוא נקודה בתוך תכן אחד. תצורה בוחרת גרסה אחת לכל נקודה.

variation part def BatteryPack :> Battery {
  variant part standardPack { attribute :>> capacity = 1.4 [kW*h]; }
  variant part largePack { attribute :>> capacity = 12 [kW*h]; }
}
part def CarLine :> Car {
  part pack : BatteryPack;
  variation part charger : Component {
    variant part noCharger;
    variant part wallbox;
  }
  assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }
}
part plugInHybrid : CarLine {
  @HolarchConfiguration;
  part :>> pack = BatteryPack::largePack;
  part :>> charger = charger::wallbox;
}
  • לגרסה יש את התכונות של הווריאציה שלה והיא יכולה להגדיר אותן מחדש: ל-largePack יש capacity כי BatteryPack הוא Battery.
  • variant x; בלי מילת מפתח של סוג הופך את השימוש הקיים x לאחת הבחירות; היא נקראת על שם x.
  • וריאציה מחזיקה רק גרסאות (והגדרות, הערות, מטא-נתונים וייבואים). וריאציה כבר מופשטת, ולכן abstract עליה מצוין כמיותר.
  • בחירת גרסה נעשית עם ערך: part :>> pack = BatteryPack::largePack;. בחירה שאינה גרסה של אותה נקודה היא שגיאה.
  • כל עוד לנקודה אין בחירה, הערך שלה אינו ידוע, ולכן טענה עליה אינה מתקיימת וגם אינה מופרת. בתצורה, משמשים הערכים של הגרסאות שנבחרו.
  • יש לסמן תצורה ב-@HolarchConfiguration (החבילה HolarchVariability, בספרייה הסטנדרטית תחת Holarch): העורך מציין אז כל נקודה שעדיין לא נבחרה בה גרסה.
  • בעורך, הוספה ▾ כותב כל אחד מאלה: שונות (הגדרה ברמת החבילה, נקודה בתוך חלק), גרסה (בתוך וריאציה), תצורה ובחירת גרסה (בתוך תצורה).
  • בהדגמת Hybrid Car, ל-CarLine יש שתי נקודות (pack ו-charger), ו-selfChargingHybrid ו-plugInHybrid הן תצורות שלו; הטענה פוסלת wallbox עם המארז הסטנדרטי.

ייצוגים טקסטואליים

ייצוג טקסטואלי כותב אלמנט בשפה אחרת: rep language "Python" /* … */ בתוך הגוף של האלמנט. הגוף נשמר כטקסט. המודל הוא מה ש-SysML שמסביב מצהיר; Holarch לעולם אינו מריץ גוף.

  • בהדגמת Hybrid Car, DriveWheels נושא את החישוב שלו ב-Python: rep language "Python" /* wheel_speed = torque.value * GEAR_RATIOS[gear] / WHEEL_RADIUS */.
  • גוף ב-"sysml" או ב-"kerml" נבדק. SpeedLimit כתוב כ-rep language "sysml" /* speed <= limit */, ו-Holarch מחשב אותו כמו אילוץ שנכתב ישירות.
  • העורך מדגיש גופי SysML ו-KerML כקוד על רקע צבעוני. שפות אחרות מוצגות כטקסט הערה.
  • הקטע ייצוג בחלונית המאפיינים מציג כל ייצוג עם השפה והגוף שלו. יש ללחוץ על הוספת ייצוג בהגדרה או בשימוש כדי להוסיף ייצוג, ועל הסרה כדי למחוק אותו.
  • תצוגת Action Flow מסמנת פעולה שלהגדרה שלה יש ייצוג, עם השפה שלו בסוגריים מסולסלים, כמו {Python}.
  • שפות מוכרות: SysML, KerML, OCL, Alf, Python, JavaScript, MATLAB, Modelica, C, שפה טבעית (naturalLanguage, English, text). מספר גרסה אחרי השם מתעלמים ממנו (OCL2.0, Python 3).
  • גוף אינו יכול להכיל */, שהיה מסיים את ההערה.

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

איך להשתמש בה

מידול מבנה

  1. בעורך, יש לפתוח חבילה (או ללחוץ על + חבילה חדשה).
  2. יש לכתוב port def לכל סוג של נקודת חיבור, עם תכונות בעלות כיוון (out attribute torque : TorqueValue;).
  3. יש לכתוב part def לכל סוג של רכיב, עם התכונות והיציאות שלו.
  4. יש לכתוב part def עבור המכלול, עם part לכל רכיב.
  5. יש לחבר את החלקים: connect a.p to b.q;, או interface name : Def connect a.p to b.q;.
  6. יש להפסיק להקליד. שורת המצב מציגה הוחל והדפדפן מציג את האלמנטים החדשים.

הוספה ▾ (או ⌃⇧Space / Ctrl+Shift+Space) כותב בשבילך כל אחד מהמבנים האלה, עם שדות למילוי. ראו הוספת מבנה.

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

  1. יש לייבא את סוגי הגדלים ואת היחידות בראש החבילה: private import ISQ::*; ו-private import SI::*;.
  2. יש להגדיר את הטיפוס של התכונה לפי סוג גודל ולתת ערך: attribute mass : MassValue = 45 [kg];.
  3. בהגדרה שיורשת את התכונה, יש להגדיר אותה מחדש עם ערך משלה: attribute redefines mass = 18 [kg];.
  4. יש להצביע על הערך. כרטיס שגיאה מופיע אם היחידה אינה מתאימה לסוג הגודל.

תיאור התנהגות

  1. יש לכתוב action def עם פרמטרי ה-in וה-out שלו.
  2. יש להוסיף שלב לכל שימוש action ולקבוע את הסדר שלהם עם first … then …; או then.
  3. יש להשתמש ב-fork וב-join לשלבים מקבילים, וב-decide וב-merge לחלופות.
  4. יש להוסיף flow of Item from a.out to b.in; בין השלבים שמעבירים פריטים.
  5. בחלק שמבצע את ההתנהגות, יש לכתוב perform action name : Def; ובחלקים שלו perform name.step;.
  6. יש לפתוח את הפעולה בתצוגת זרימת פעולות כדי לראות אותה משורטטת (ראו תצוגות SysML v2).

כתיבת דרישה ועקיבה אחריה

  1. יש לכתוב requirement <'ID'> name { doc /* The system shall … */ subject s : Def; }.
  2. יש להוסיף require constraint { … } כשאפשר לבדוק את הדרישה מול ערכים.
  3. יש לכתוב satisfy name by somePart; היכן שהתכן עומד בה.
  4. יש לכתוב verification שהמטרה שלו מאמתת (verify) אותה.
  5. יש לפתוח את צרכים ודרישות → דרישות: הדרישה מופיעה עם המספר שלה, ו-אימות → RVTM מציג כיצד היא מאומתת. ראו דרישות ואימות בפרויקטים של SysML v2.

סימון ערך כ-TBD או כ-TBR

כתיבת TBD במקום ערך אינה SysML תקני. במקום זאת יש להשתמש במטא-נתונים של Holarch.

  1. יש לייבא אותם: private import HolarchMetadata::*;.
  2. יש להוסיף קידומת לתכונה: #TBD attribute chargerPower : PowerValue; (עדיין ללא ערך) או #TBR attribute limit : TimeValue = 0.5 [h]; (ערך לסקירה).
  3. כדי לרשום בעלים ונימוק, יש לכתוב את הצורה הארוכה בגוף של התכונה: @TBD { owner = "Powertrain lead"; rationale = "The charging standard is not chosen yet."; due = "2026-12-01"; }.

מרשם TBD/TBR מציג את הערכים האלה. TBD ו-TBR מתמחים ב-ModelingMetadata::StatusInfo, ולכן כלי SysML v2 אחרים קוראים אותם כסימוני מצב. הוספה ▾ → ערך TBD וערך TBR כותבים אותם בשבילך.

מציאת שם בספרייה

  1. יש לפתוח את ספרייה סטנדרטית מכלי סרגל הניווט.
  2. יש להקליד חלק מהשם ב-חיפוש חבילה או הגדרה…, למשל MassValue.
  3. יש ללחוץ על העתקת השם בשורה. השם המלא, כאן ISQBase::MassValue, מועתק.
  4. יש להדביק אותו בעורך, או לייבא את החבילה שלו ולהשתמש בשם הקצר.

דוגמה מעשית: קריאת הדרישה של הסדאן

הדוגמה הזו עוקבת אחרי דרישה אחת לאורך הטקסט של הדגמת Hybrid Car.

  1. יש לפתוח את ההדגמה ולבחור VehicleRequirements ברשימה חבילות של העורך.
  2. יש למצוא את requirement def <'VR-1'> CurbMass. ה-require constraint { car.curbMass <= limit } שלה משווה את המסה העצמית של הנושא ל-limit.
  3. יש למצוא את requirement carSpec. היא מכילה requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }. השימוש מגדיר מחדש את limit עם היעד ברמת החבילה maxCurbMass = 1650 [kg].
  4. יש למצוא את satisfy carSpec by fleet.sedan;. לחיצה עם ⌘ / Ctrl על sedan: העורך פותח את Vehicles ב-part sedan : Car, שם attribute redefines curbMass = 1580 [kg]; נותן את הערך.
  5. בחזרה ב-VehicleRequirements, יש למצוא את verification def CurbMassTest. המטרה שלו verify carSpec.sedanMass; הופכת אותו למקרה אימות של VR-1.1, ו-verification sedanWeighing : CurbMassTest { subject car = fleet.sedan; } מחיל אותו על הסדאן.
  6. יש לשנות את 1580 [kg] ל-1700 [kg] ב-Vehicles ולהפסיק להקליד. הסדאן חורג עכשיו מהמגבלה של 1650 ק״ג, והעורך מציג ב-VehicleRequirements אזהרה שהדרישה אינה מתקיימת על ידי sedan, עם האילוץ שאינו מתקיים והערכים שלו. ביטול עם ⌘Z / Ctrl+Z.

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

  • “…” is not defined here. (השם אינו מוגדר כאן.) השם מאוית לא נכון או שהחבילה שלו אינה מיובאת. יש להוסיף private import Package::*;, או לכתוב את השם המלא.
  • חסר ;. כל הצהרה מסתיימת ב-; או בגוף { … }. The declaration does not end. Add ; or a { … } body. (ההצהרה אינה מסתיימת.)
  • :> לעומת :>>. יש להשתמש ב-:> כדי להתמחות או ליצור תת-קבוצה; ב-:>> כדי להחליף תכונה שעברה בירושה. הגדרה מחדש של תכונה שלא עברה בירושה נותנת “x” is not inherited by “y”. (x אינה עוברת בירושה ל-y.)
  • יחידות דורשות ייבוא. 5 [kg] מזוהה רק היכן ש-SI גלוי.
  • שני חברים עם אותו שם. “x” is already used in this namespace. (השם כבר בשימוש במרחב השמות הזה.) יש לשנות את השם של אחד מהם; גרסה מגדירה מחדש במקום זאת.
  • verify מחוץ למטרה. יש למקם אותו ב-objective { verify R; } של מקרה אימות.
  • מילות מפתח כשמות. מילים כמו part, state או action שמורות. יש לשים אותן במירכאות ('state') או לבחור שם אחר.

במה Holarch תומך

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

תחוםנתמך
חבילות ומרחבי שמותpackage, חבילות מקוננות, library package (לקריאה בלבד), doc, comment … about, הערות // ו-//* */, alias … for …, public/private/protected, שמות קצרים <'1.2'>, שמות במירכאות
ייבואייבואי חברות ומרחבי שמות, ::*, ::** רקורסיבי, ייבואים מסוננים [@Kind]
הגדרות ושימושיםpart, attribute, item, port, connection, interface, flow, action, state, requirement, constraint, calc, use case, analysis, verification, view, viewpoint, concern, enum, occurrence, allocation, metadata; ref, abstract, in/out/inout, end
התמחות:>/specializes, :/defined by, :>/subsets, :>>/redefines, היפוך ~, disjoint, שרשראות תכונות a.b.c
ריבויים[n], [n..m], [*], [0..*], ordered, nonunique, ביטויים כגבולות
ערכים ויחידות=, :=, default, גדלים 5 [kg], ביטויי יחידות [m/s^2], סוגי הגדלים של ISQ והיחידות של SI והיחידות האמריקאיות המקובלות מהספרייה הסטנדרטית, בדיקות ממדים
מבנהיציאות ויציאות הפוכות, connect, ממשקים עם קצוות, קצוות מחבר בעלי שם עם ריבויים, bind, flow of T from … to …, message
פעולותפרמטרים, perform, רצפים (first … then …, then), fork, join, decide, merge, תנאי שמירה, accept, send, assign, if, while, for, loop, start, done, terminate
מצביםentry/do/exit, מעברים עם טריגר, תנאי שמירה והשפעה, מצבי parallel, מצבים מקוננים, exhibit
דרישותsubject, actor, stakeholder, require constraint, assume constraint, frame concern, satisfy … by …, verify, שמות קצרים כמזהים, doc כטקסט הדרישה
אילוצים וחישוביםהגדרות ושימושים של constraint ו-calc, return, assert constraint, קריאות, ביטויי KerML עם חשבון, השוואה, לוגיקה, if ? else ופעולות על רצפים, חישוב עם יחידות
מקרי שימוש, ניתוח ואימותsubject, actor, objective, include use case, מקרי ניתוח עם תוצאת return, מקרי אימות עם verify ופסק דין
תצוגותview, view def, expose (עם ::*, ::** ומסננים), filter, viewpoint, frame, render, הגדרות התצוגה הסטנדרטיות
הקצאה ועקיבותallocate a to b, הגדרות הקצאה, dependency from … to …
יחידיםהגדרות ושימושים של individual, snapshot ו-timeslice (גם אחרי then), הערכים והרצפים שלהם
שונותהגדרות ושימושים של variation, חברי variant והפניות לגרסאות (variant x;), בחירות לפי ערך, תצורות המסומנות ב-@HolarchConfiguration (HolarchVariability)
מטא-נתונים@Name { … }, הקידומת #Name, metadata Name about …, החבילות HolarchMetadata (TBD, TBR) ו-HolarchFrameworks של Holarch; metadata def שהמשתמש מגדיר; מילות מפתח שהמשתמש מגדיר ומטא-נתונים סמנטיים (#fault def …)

נשמר כפי שנכתב, לא מפורש

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

עדיין לא זמין

  • ייבוא קובצי KerML (.kerml).
  • ביצוע commit ל-main, תגים ומיזוגים דרך Systems Modeling API: כלים אחרים מבצעים commit לענפים של בקשות שינוי, שמאשר מחיל ב-Holarch (ראו ה-API וה-MCP בפרויקטים של SysML v2).
  • הרחבות שפה מעבר למילות מפתח שהמשתמש מגדיר ומטא-נתונים סמנטיים.

בדיקות

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

תחוםמה נבדקהודעה לדוגמה
תחבירתווים, הערות, מחרוזות, סוגריים מסולסלים, ;, שמות ואסימונים צפוייםThis brace has no partner. Add the matching { or }, or delete this one. (לסוגר הזה אין בן זוג.)
שמותשמות שלא זוהו, דו-משמעיים, לא חוקיים, כפולים (אזהרה) ופרטיים“Batery” is not defined here. Check the spelling, or import its package. (השם אינו מוגדר כאן.)
טיפוס והתמחותמעגלים; קביעת טיפוס והתמחות לפי הגדרה מהסוג הנכון; תת-קבוצות והגדרה מחדש של תכונות; הגדרה מחדש של תכונות שעברו בירושה בלבד“capacity” is not inherited by “Car”. Specialize its type, or subset it with :> instead. (התכונה אינה עוברת בירושה.)
ריבוייםגבולות תקינים ושלמים; הגדרה מחדש שאינה רחבה יותר ממה שהיא מגדירה מחדשMultiplicity [3..1] is not valid. Use a lower bound from 0 up to the upper bound. (הריבוי אינו תקין.)
יחידות וערכיםממדים תואמים, יחידות חסרות, שמות יחידות, טיפוסי מספריםThe units do not match: kg and s. Convert one side to a compatible unit. (היחידות אינן תואמות.)
ביטוייםתחביר, טיפוסי אופרנדים, ארגומנטים של חישובים, תנאים בוליאנייםThe condition must be true or false; it is a number. Write a comparison such as x > 0. (התנאי חייב להיות אמת או שקר.)
מבנהקצוות חיבור הם תכונות, ממשקים מחברים יציאות, כיווני יציאות, זרימות והודעות, טיפוסי פריטי זרימה, טיפוסי קשירהThese port directions do not fit together. Conjugate one port (~) or change a direction. (כיווני היציאות אינם מתאימים זה לזה.)
פעולותרצפים בין פעולות של אותו גוף, מספרי כניסות ויציאות של צמתי בקרה, תנאי שמירה של החלטות ו-else, start ו-done, השמות, יעדי perform, הערכים שלולאת for עוברת עליהם מול הטיפוס של משתנה הלולאהthen needs an earlier action. Add an action or first … then …. (then דורש פעולה קודמת.)
מצביםמעברים בין מצבים של אותו גוף, entry/do/exit אחד לכל מצב, מעברים התחלתיים, אזורים מקביליים, יעדי exhibit, השפעת do של מעבר (send למשהו שיכול לקבל, assign, accept, action או פעולה בעלת שם), המטען של טריגר מול הפריטים של היציאה שלו, טריגר על ערך ספרייה חשוף כמו Real (אזהרה), טריגרי at שמציינים זמן“electric” has substates but no initial transition, so none of them is entered. Add entry; then <first state>;. (למצב יש תת-מצבים אבל אין מעבר התחלתי.)
דרישות, מקרים ותצוגותחברים במקום הנכון, נושא אחד, יעדי satisfy/verify/require, טיפוסי נושאים, יעדי expose ו-import, יעדי frameverify belongs in the objective of a verification case. Move it into objective { … }. (verify שייך למטרה של מקרה אימות.)
ייצוגים טקסטואלייםגופי SysML ו-KerML מנותחים ומצהירים על האלמנט שהם מייצגים; שפות לא מוכרות מצוינותThe representation of “SpeedLimit” declares a part definition, not a constraint definition. Make the body declare “SpeedLimit” itself. (הייצוג מצהיר על הגדרה מסוג שגוי.)
מופעים, תמונות מצב ופרוסות זמןindividual רק על מופעים ועם הגדרת יחיד אחת בדיוק; snapshot/timeslice רק על שימושי מופע בתוך מופע; פרוסת זמן בתוך צילום מצב (אזהרה)“parked” is individual, but none of its definitions is. Type it by an individual definition, or remove individual. (אף אחת מההגדרות שלו אינה יחיד.)
שונותוריאציה מחזיקה רק גרסאות; גרסה נמצאת בווריאציה ומהסוג שלה; בחירה היא גרסה של הנקודה שלה; abstract על וריאציה מיותר (הערה); הנקודות הפתוחות של תצורה (הערה)“compact” is not a variant of “pack”. Choose one of: standardPack, largePack. (זו אינה גרסה של הנקודה.)
מילות מפתח שהמשתמש מגדיר#Name מציין הגדרת מטא-נתונים; הצהרה ללא מילת מפתח של השפה משתמשת במטא-נתונים סמנטיים (אזהרה); מטא-נתונים מסמנים רק את הסוגים שה-annotatedElement שלהם מתיר; טיפוס בסיס סמנטי הוא הגדרה או שימוש, מתאים לאלמנט שהוא מסמן (אזהרה) ואינו יוצר מעגל“safetyCritical” applies to PartDefinition, not to “invert” (ActionUsage). Move it, or remove it. (מילת המפתח חלה על סוג אחר.)
ערכי מטא-נתוניםכל תכונת חובה של הגדרת מטא-נתונים שהמשתמש מגדיר מקבלת ערך (אזהרה); כל ערך וכל ברירת מחדל מתאימים לטיפוס של התכונה שלהם (Boolean, String, מספרים שלמים, מניות); האילוצים של ההגדרה מתקיימים עבור הערכים שניתנו; גוף מטא-נתונים רק מגדיר מחדש את התכונות של ההגדרה; הגדרות מטא-נתונים מופשטות אינן מוחלות; מטא-נתונים סמנטיים שנכתבו עם about (אזהרה)The values of “SafetyRating” break its constraint levelRange: level >= 1 and level <= 4. Change the values. (הערכים מפרים את האילוץ.)
חישובאילוצים, דרישות ומטרות שאינם מתקיימים עבור הערכים הנוכחיים“sedanMass” is not met by “sedan”: … is false (…). Change the design values or the requirement. (הדרישה אינה מתקיימת.)

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

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

  • פתיחה מ-הגדרות → ספרייה סטנדרטית בכלי סרגל הניווט. בפרויקטים של LML הוא אינו קיים.
  • תיקיות. הצד הימני מציג את קובצי הספרייה לפי תיקייה: Kernel Libraries, Systems Library, Domain Libraries (Analysis, Cause and Effect, Geometry, Metadata, Quantities and Units, Requirement Derivation) ו-Holarch (החבילה HolarchMetadata עם TBD ו-TBR, HolarchVariability עם HolarchConfiguration, ו-HolarchRequirements עם Objective).
  • קובץ. יש לבחור קובץ כדי לראות את החבילות שלו, כל אחת עם התיעוד שלה וטבלה של ההגדרות שלה: שם, סוג ותיעוד.
  • חיפוש. הקלדה ב-חיפוש חבילה או הגדרה… מחפשת בשמות ובתיעוד של כל הקבצים. התוצאות מציגות את הקובץ; לחיצה עליה פותחת אותו. Esc מנקה.
  • העתקת השם מעתיק את השם המלא של אלמנט, כמו ISQ::MassValue, לשימוש בעורך.
  • הצגת הטקסט מציג את קובץ הספרייה כפי שנכתב; הצגת הגדרות חוזר לטבלאות.

הספרייה היא ספריית הגרסה של SysML v2, עם תיקון אחד: tonne (כינוי 'metric ton') מומר ל-1000 ק״ג; בקובץ הגרסה כתוב 0.001 ק״ג. המודל מפנה אליה לפי שם; היא אינה מועתקת לפרויקט, ואינה חלק מייצוא .sysml.

מגבלות

  • מסמך טקסט גדול מ-8 MB אינו נבדק: This text is larger than 8 MB and is not checked. Split it into several packages. (הטקסט גדול מ-8 MB ואינו נבדק.)
  • שורה ארוכה מ-64 KB אינה נבדקת.
  • קינון עמוק מ-256 רמות אינו נבדק.
  • אי אפשר לערוך את הספרייה הסטנדרטית.

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