מדריך · SysML v2
SysML v1 מול v2: במה שתי השפות נבדלות
האזנה למדריך 20 דק׳
ל-SysML v1 ול-SysML v2 יש מטרה משותפת ושמות רבים משותפים, אבל SysML v2 היא שפה חדשה ולא מהדורה מתוקנת. המדריך הזה משווה בין השתיים זו לצד זו: היסוד, הגדרות ו-usages, הסימון הטקסטואלי, יחידות, ports, התנהגות, דרישות, תצוגות, ה-API, ומה כרוך בהגירה מ-v1 ל-v2.
בדף זה
- במבט חטוף
- היסוד: פרופיל UML מול KerML
- הגדרות ו-usages במקום בלוקים ומאפיינים
- סימון טקסטואלי סטנדרטי
- ספרייה סטנדרטית, גדלים ויחידות
- Ports, ממשקים וחיבורים
- התנהגות: פעולות ומצבים
- דרישות ו-verification cases
- תצוגות במקום דיאגרמות משורטטות
- ה-Systems Modeling API והחלפה ב-JSON
- הגירת מודל מ-SysML v1 ל-v2
- איך הרשימות נבדקו
- לנסות ב-Holarch
- לאן ממשיכים
במבט חטוף
קוראים שמכירים את SysML v1 יזהו את רוב המושגים ב-SysML v2. מה שהשתנה הוא האופן שבו הם בנויים ומידת הדיוק שבה הם מוגדרים. הטבלה מסכמת את ההשוואה; לכל שורה יש סעיף משלה בהמשך.
| נושא | SysML v1 | SysML v2 |
|---|---|---|
| יסוד | פרופיל של UML 2: סטריאוטיפים על תת-קבוצה של מטא-מחלקות UML | מטא-מודל משלה על Kernel Modeling Language (KerML), עם סמנטיקה שמוגדרת בספרייה פורמלית |
| מבנה | בלוקים עם part, reference ו-value properties | הגדרות ו-usages לכל סוג של רכיב: part def ו-part, port def ו-port, וכן הלאה |
| סימון | גרפי (תשעה סוגי דיאגרמות); אין טקסט סטנדרטי לכל המודל | סימון טקסטואלי סטנדרטי וסימון גרפי סטנדרטי לאותו מודל |
| גדלים ויחידות | Value types עם יחידות, דרך מודל יחידות וספריות מודל | גדלי ISQ ויחידות SI בספרייה הסטנדרטית, בשימוש ישיר בערכים כמו 6.5 [kg] |
| ממשקים | Full ports ו-proxy ports, interface blocks, flow properties, item flows על connectors | הגדרות port עם features מכוונים, צימוד ~, הגדרות interface עם קצוות מוקלדים, flows ו-binding |
| התנהגות | Activities, state machines ו-interactions מ-UML, שמקושרים למבנה באמצעות allocation | פעולות, מצבים והודעות כ-occurrences, שמקושרים למבנה באמצעות perform ו-exhibit |
| דרישות | מחלקה עם סטריאוטיפ, מזהה וטקסט; אילוצים נמצאים בנפרד ב-constraint blocks | דרישה היא constraint עם subject; טקסט ותנאי שאפשר לבדוק ברכיב אחד |
| אימות | מקרי בדיקה שמקושרים ב-verify | Verification cases עם objective ו-verdict |
| דיאגרמות | שרטוטים שהכלי מחזיק; פריסות כמעט אף פעם אינן עוברות בין כלים | תצוגות הן רכיבי מודל שקובעים מה הן מציגות; הכלי מצייר אותן |
| החלפה | קובצי XMI, עם הבדלים בין כלים | קובצי טקסט, JSON, וה-Systems Modeling API הסטנדרטי |
היסוד: פרופיל UML מול KerML
SysML v1 מוגדרת כפרופיל של UML 2. היא לוקחת תת-קבוצה של UML ומוסיפה סטריאוטיפים: בלוק הוא מחלקת UML עם הסטריאוטיפ «block», דרישה היא מחלקה עם «requirement», flow property היא property עם «flowProperty». זה הפך את SysML v1 לקלה לאימוץ, כי כלי UML יכלו לארח אותה, אבל זה גם אומר שמושגי מערכות כופפו כדי להתאים למושגי תוכנה, ושהמשמעות של מבנים רבים הגיעה מהסמנטיקה של UML, שנכתבה עבור תוכנה.
SysML v2 מוותרת על בסיס ה-UML. היא בנויה על Kernel Modeling Language (KerML), שפה קטנה יותר שלליבה שלה ניתנת משמעות מדויקת בספרייה של מודלי KerML. SysML v2 מוסיפה מעליה את מושגי הנדסת המערכות: parts, ports, פעולות, מצבים, דרישות, cases ותצוגות. כל מבנה של SysML v2 מוגדר כהתמחות של משהו בספרייה הזאת. בפועל המשמעות היא:
- מבנה והתנהגות חולקים יסוד אחד. parts ופעולות הם שניהם occurrences שקיימים לאורך זמן, כך ש-part יכול לבצע פעולה (perform) או להציג מצב (exhibit) בלי שכבת allocation נפרדת.
- הכלים מסכימים זה עם זה במידה רבה יותר על משמעות המודל, כי המשמעות נמצאת במפרט ובספריות שלו ולא בפרשנות של כל כלי.
- סטריאוטיפים כבר אינם מנגנון ההרחבה. SysML v2 משתמשת בהגדרות metadata להערות ייעודיות לכלי או לתחום.
הגדרות ו-usages במקום בלוקים ומאפיינים
ב-SysML v1 הבלוק הוא הרכיב המרכזי: block definition diagram מגדירה בלוקים, ו-internal block diagram מציגה את ה-parts של בלוק אחד. part property מוקלדת לפי בלוק; value property מוקלדת לפי value type. מתן ערך ל-part אחד ששונה מברירת המחדל של הבלוק שלו, למשל משאבה כבדה יותר בגרסת מוצר אחת, דורש מעקף: בלוק מתמחה שמגדיר מחדש את ה-property, property-specific type, או instance specification.
SysML v2 מכלילה את זה לדפוס אחד לכל רכיב: הגדרה (definition) אומרת מהו סוג של דבר, usage הוא דבר כזה בהקשר. usages מקוננים, ו-usage מקונן יכול להגדיר מחדש את מה שהוא יורש עם ערך משלו. אותו דפוס חל על attributes, ports, פעולות, מצבים, דרישות ותצוגות.
package CoolingLoop {
doc /* The engine cooling loop of a small generator set. */
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
part def Pump {
attribute mass : MassValue;
attribute shaftPower : PowerValue;
}
part def ElectricPump :> Pump {
attribute supplyVoltage : ElectricPotentialValue;
}
part def Radiator {
attribute mass : MassValue;
attribute heatRejection : PowerValue;
}
part def CoolingSystem {
part pump : ElectricPump {
attribute redefines mass = 2.4 [kg];
attribute redefines shaftPower = 150 [W];
attribute redefines supplyVoltage = 24 [V];
}
part radiator : Radiator {
:>> mass = 6.5 [kg];
:>> heatRejection = 18 [kW];
}
attribute totalMass : MassValue = pump.mass + radiator.mass;
}
}
| SysML v1 | SysML v2 ברשימה הזאת |
|---|---|
בלוק Pump עם value properties | part def Pump עם attributes |
הכללה מ-ElectricPump אל Pump | התמחות part def ElectricPump :> Pump |
part property pump של CoolingSystem, שמוקלדת לפי הבלוק | part usage part pump : ElectricPump |
| ערך ייעודי להקשר דרך בלוק מתמחה או instance | attribute redefines mass = 2.4 [kg] ישירות על ה-usage |
| ערך נגזר עם constraint block ו-parametric diagram | totalMass כביטוי על ה-attribute |
:>> הוא הצורה המקוצרת של redefines. Reference properties ב-v1, שמצביעות על part שנמצא בבעלות במקום אחר, הופכות ל-usages מסוג ref ב-v2.
סימון טקסטואלי סטנדרטי
ל-SysML v1 אין צורת טקסט סטנדרטית למודל שלם. המודל נמצא במאגר של הכלי, אנשים עובדים בדיאגרמות, וקבצים עוברים בין כלים כ-XMI, שמיועד למכונות ולא לקריאה. טקסט מופיע רק במקומות מסוימים: ביטויי אילוצים, התנהגויות אטומות ושפות פעולה בכלים מסוימים.
ל-SysML v2 יש סימון טקסטואלי שמכסה את כל השפה, לצד סימון גרפי. שניהם מציגים את אותו מודל. כל רשימה בדף הזה היא הסימון הטקסטואלי הזה; מדריך SysML v2 בונה בו מודל שלם צעד אחר צעד. טקסט משנה את הדרך שבה צוות יכול לעבוד:
- אפשר לסקור מודל שורה אחר שורה, להשוות אותו ב-diff, ולשמור אותו בבקרת גרסאות יחד עם שאר הנתונים ההנדסיים.
- מהנדסים יכולים להקליד מודל מהר, להעתיק דפוסים בין מודלים, ולהפיק חלקים ממנו בסקריפטים.
- אפשר לבדוק מודל כמו קוד מקור: שמות שלא נפתרו, יחידות שגויות ו-ports שאינם תואמים מדווחים במקום שבו הם מופיעים.
הסימון הטקסטואלי אינו מחליף דיאגרמות. הוא הופך את המודל לתוצר העיקרי, והדיאגרמות הופכות לתצוגות שלו, כפי שמתואר בהמשך.
ספרייה סטנדרטית, גדלים ויחידות
SysML v1 מקלידה value property לפי value type, שיכול לשאת יחידה וסוג גודל. המפרט כולל מודל לגדלים ויחידות, וספריות מודל ליחידות נפוצות, אבל הכלים נבדלים באילו ספריות הם מספקים ועד כמה הם בודקים יחידות בביטויים.
SysML v2 מגיעה עם ספרייה סטנדרטית כחלק מהשפה. היא כוללת את מערכת הגדלים הבינלאומית (ISQ), יחידות SI (SI), יחידות אמריקאיות מקובלות, טיפוסים סקלריים, אוספים והגדרות התצוגה הסטנדרטיות. ברשימה שלמעלה:
attribute mass : MassValueאומר שה-attribute הוא מסה, לא מספר.6.5 [kg]הוא ערך גודל: מספר עם יחידה, שנכתב בתוך השורה.pump.mass + radiator.massמחבר שתי מסות. כלי שמחשב יחידות יכול לדחות ביטוי שמחבר מסה להספק, או מסה שניתנה בוולטים.
Ports, ממשקים וחיבורים
ה-ports ב-SysML v1 עברו כמה תכנונים. בגרסאות המוקדמות היו standard ports ו-flow ports; גרסאות מאוחרות יותר החליפו אותם ב-full ports, proxy ports ו-interface blocks עם flow properties. ל-flow property יש כיוון (in, out או inout), אפשר לצמד port כדי להפוך את הכיוונים, ו-item flows על connectors אומרים מה נע. מודלים רבים קיימים של v1 עדיין מערבבים את סוגי ה-ports הישנים והחדשים.
SysML v2 שומרת על הרעיונות והופכת אותם לאחידים. הגדרת port מפרטת features מכוונים, הצד המקבל משתמש בצמוד ~ של אותה הגדרה, והגדרת interface מתארת סוג של חיבור עם קצוות מוקלדים.
package CoolantInterfaces {
private import ISQ::*;
item def Coolant {
attribute temperature : ThermodynamicTemperatureValue;
}
port def CoolantPort {
out item coolant : Coolant;
}
interface def Hose {
end supply : CoolantPort;
end ret : ~CoolantPort;
}
part def Pump {
port outlet : CoolantPort;
}
part def Radiator {
port inlet : ~CoolantPort;
}
part def Loop {
part pump : Pump;
part radiator : Radiator;
interface hose : Hose connect pump.outlet to radiator.inlet;
}
}
| SysML v1 | SysML v2 |
|---|---|
| Interface block עם flow properties | port def עם features מסוג in, out או inout |
| proxy port או full port שמוקלד לפי ה-interface block | usage מסוג port שמוקלד לפי הגדרת ה-port |
| טיפוס port מצומד | ~CoolantPort |
| Connector, אופציונלית מוקלד לפי association block | connect … to …, או usage מסוג interface שמוקלד לפי interface def |
| Binding connector | bind a = b |
| Item flow על connector | usage מסוג flow, או item feature של ה-port |
כיוון שהכיוונים הם חלק מההגדרות, בודק יכול להזהיר כששני הקצוות של חיבור שולחים את אותו feature ואף אחד מהם אינו מקבל אותו.
Loop מהרשימה ב-Interconnection View, המקבילה ב-SysML v2 ל-internal block diagram.התנהגות: פעולות ומצבים
SysML v1 שואלת את ההתנהגות שלה מ-UML: activities עם סמנטיקת זרימת אסימונים, state machines, ו-interactions לדיאגרמות רצף. התנהגות מקושרת למבנה שמבצע אותה באמצעות allocation, לעיתים קרובות עם activity partitions (מסלולי שחייה) או קשרי «allocate».
ב-SysML v2, פעולות ומצבים הם occurrences, כמו parts. להגדרת action יש פרמטרי קלט ופלט; successions (first … then …) נותנות את הסדר ו-flows אומרים מה עובר בין צעדים. להגדרת state יש מצבים ומעברים עם triggers, guards ו-effects. part מבצע (perform) פעולה ומציג (exhibit) מצב, כך שהקישור למבנה הוא חלק מהשפה ולא קשר שנוסף.
package PumpBehavior {
private import ISQ::*;
item def StartCommand;
item def StopCommand;
item def Coolant;
action def Circulate {
in item cold : Coolant;
out item warm : Coolant;
}
action def CoolEngine {
action pumpCoolant : Circulate;
action rejectHeat : Circulate;
flow pumpCoolant.warm to rejectHeat.cold;
first start then pumpCoolant;
first pumpCoolant then rejectHeat;
first rejectHeat then done;
}
state def PumpModes {
entry; then off;
state off;
state running;
transition first off accept StartCommand then running;
transition first running accept StopCommand then off;
}
part def Pump {
exhibit state modes : PumpModes;
}
}
| SysML v1 | SysML v2 |
|---|---|
| Activity עם actions, control flows ו-object flows | action def עם action usages, successions ו-flow |
| צמתי fork, join, decision ו-merge | fork, join, decide ו-merge |
| Call behavior action | action usage שמוקלד לפי הגדרת action אחרת |
| Partition או «allocate» מ-activity אל בלוק | perform ב-part |
| State machine בבעלות בלוק | state def, עם exhibit state ב-part |
| מעבר עם trigger, guard ו-effect | transition … accept … if … do … then … |
| Interaction (דיאגרמת רצף) | Occurrences עם message, שמוצגים ב-Sequence View |
PumpModes ב-State Transition View, שמצויר מהטקסט שלמעלה.דרישות ו-verification cases
דרישה ב-SysML v1 היא מחלקה עם סטריאוטיפ ושתי מחרוזות: מזהה וטקסט. קשרים מחברים אותה לשאר המודל: satisfy, verify, derive, refine, trace ו-copy. מקרה בדיקה הוא התנהגות שמסומנת «testCase». בדיקת דרישה עם מספרים דורשת constraint block נפרד ב-parametric diagram, ושום דבר בשפה אינו קושר את האילוץ הזה לטקסט של הדרישה.
ב-SysML v2 הגדרת requirement היא סוג של הגדרת constraint. יש לה subject (על מה הדרישה), ייתכן שיש לה attributes כמו גבול, והיא מכילה את התנאי שחייב להתקיים. טקסט ה-doc והתנאי נמצאים ברכיב אחד. Verification case מציין ב-objective שלו את הדרישה שהוא מאמת ומחזיר verdict.
package CoolingRequirements {
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
part def CoolingSystem {
attribute heatRejection : PowerValue;
}
part cooling : CoolingSystem {
attribute redefines heatRejection = 18 [kW];
}
requirement def <'CR-1'> HeatRejection {
doc /* The cooling system shall reject at least the engine's waste heat at full load. */
subject system : CoolingSystem;
attribute wasteHeat : PowerValue;
require constraint { system.heatRejection >= wasteHeat }
}
requirement coolingSpec : HeatRejection {
subject system : CoolingSystem;
attribute redefines wasteHeat = 15 [kW];
}
satisfy coolingSpec by cooling;
verification def <'VC-1'> HeatRunTest {
doc /* Run the engine at full load on a test stand and measure the heat the radiator rejects. */
subject system : CoolingSystem;
objective {
verify coolingSpec;
}
return verdict : Boolean = system.heatRejection >= coolingSpec.wasteHeat;
}
verification heatRun : HeatRunTest {
subject system = cooling;
}
}
<'CR-1'>הוא שם קצר, הבית ב-v2 של מזהה הדרישה מ-v1.require constraintהוא הצורה הניתנת לבדיקה של הטקסט. עם 18 kW מול 15 kW, כלי שמחשב אילוצים מדווח שעומדים בדרישה.satisfyו-verifyשומרים על המשמעות שלהם מ-v1. Derive, refine ו-trace ממופים ל-dependencies או ל-requirement usages שמקוננים בדרישות אחרות; הצוותים מחליטים איך למדל אותם.- SysML v2 מוסיפה לדרישות הנחות (
assume constraint), בעלי עניין ו-concerns, ו-use cases ו-analysis cases לצד verification cases.
תצוגות במקום דיאגרמות משורטטות
דיאגרמה ב-SysML v1 היא שרטוט שהכלי מחזיק: מישהו בוחר אילו רכיבים מופיעים והיכן. שתי דיאגרמות של אותו בלוק יכולות לחלוק על מה שהוא מכיל, ופריסות דיאגרמה כמעט אף פעם אינן שורדות החלפה בין כלים. גרסאות v1 מאוחרות יותר הוסיפו views ו-viewpoints, אבל משתמשים בהם בעיקר למסמכים, לא לדיאגרמות שמהנדסים משרטטים כל יום.
ב-SysML v2 תצוגה היא רכיב של המודל. היא מציינת מה להציג עם expose, אילו סוגי רכיבים לכלול עם filter, ובאיזו הגדרת תצוגה סטנדרטית לצייר אותה. הפריסה נשארת לכלי; מה שהתצוגה מכילה נמצא במודל ואפשר לקרוא אותו בטקסט.
package CoolingViews {
private import StandardViewDefinitions::*;
part def Pump;
part def Radiator;
part def Loop {
part pump : Pump;
part radiator : Radiator;
connect pump to radiator;
}
view loopConnections : InterconnectionView {
expose Loop;
}
view structure : GeneralView {
filter @SysML::PartDefinition;
expose CoolingViews::*;
}
}
| דיאגרמת SysML v1 | תצוגת SysML v2 |
|---|---|
| Block definition, package, requirement diagram | General View, עם מסננים |
| Internal block diagram | Interconnection View |
| Activity diagram | Action Flow View |
| State machine diagram | State Transition View |
| Sequence diagram | Sequence View |
| Parametric diagram | General View או Interconnection View של אילוצים וה-bindings שלהם |
| Use case diagram | General View של use cases ושחקנים |
| טבלאות ומטריצות (ייעודיות לכלי ב-v1) | Grid View |
ה-Systems Modeling API והחלפה ב-JSON
מודלים של SysML v1 עוברים בין כלים כ-XMI. XMI הוא תקן, אבל כל כלי כותב גרסה משלו, סטריאוטיפים ונתוני דיאגרמה משלו, ולכן החלפה דורשת בדרך כלל בדיקה לכל זוג כלים, ואין דרך סטנדרטית שבה תוכנה יכולה לתשאל מודל שמוחזק בכלי אחר.
SysML v2 מגיעה עם המפרט Systems Modeling API and Services. הוא מגדיר שירותים לפרויקטים, ענפים, commits, רכיבים ושאילתות, ו-binding של REST/HTTP שבו כל רכיב הוא אובייקט JSON עם @id ו-@type. ההשלכות:
- סקריפט, לוח מחוונים או כלי אחר יכולים לקרוא ולתשאל מודל דרך ממשק מתועד אחד במקום ממשק ייעודי לספק.
- מזהי הרכיבים נעים עם המודל, כך שקישורים בין כלים יכולים לשרוד החלפה.
- מודלים מנוהלים בגרסאות כ-commits על ענפים, בדומה לקוד מקור.
קובצי טקסט ו-JSON משלימים זה את זה: טקסט מיועד לאנשים לקריאה, לסקירה ול-diff; JSON שומר את המזהים שהכלים נשענים עליהם.
הגירת מודל מ-SysML v1 ל-v2
העברת מודל v1 ל-v2 היא תרגום בין שפות, לא שדרוג קובץ, והכלי היעד קובע כמה ממנה אוטומטי: מה לבדוק בכלי SysML v2 עוסק בייבוא v1 בין שאר הבדיקות. חלק גדול ממודל טיפוסי ממופה ישירות, ואת חלקו עדיף לבנות מחדש בדרך של v2 מאשר לתרגם מילולית.
מה ממופה בצורה נקייה
- חבילות והקינון שלהן.
- בלוקים להגדרות part, part properties ל-part usages, reference properties ל-usages מסוג
ref, הכללות להתמחויות. - Value properties ל-attributes, עם גדלים ויחידות כשל-value types של v1 היו יחידות.
- Interface blocks עם flow properties להגדרות port; proxy ports ו-full ports ל-port usages; connectors לחיבורים או לממשקים.
- מזהי דרישות וטקסט לשמות קצרים ול-
doc; קשרי satisfy ו-verify. - State machines להגדרות state; activities בנויות היטב להגדרות action עם successions ו-flows.
מה צריך חשיבה מחדש
- ערכים ייעודיים להקשר. Property-specific types, instance specifications ו-redefinitions שנוצרו רק כדי לקבוע ערך הופכים ל-redefinitions פשוטות על usages. תרגום מילולי שומר על המעקף.
- דרישות של טקסט בלבד. v2 מאפשרת אותן, אבל הרווח מגיע מהוספת התנאי. יש להחליט אילו דרישות מקבלות
require constraint. - Constraint blocks ו-parametric diagrams. הם הופכים להגדרות constraint ו-calculation, שלעיתים קרובות נכתבות כביטויים ישירות על attributes, כמו
totalMassלמעלה. - Allocation. Activity partitions וקשרי «allocate» מהתנהגות למבנה הופכים ל-
performול-exhibitבמקום שבו המשמעות היא “ה-part הזה עושה את זה”. - סוגי ports ישנים. Standard ports ו-flow ports ממודלים מוקדמים של v1 דורשים את רוב העבודה, כי ל-v2 יש מושג port אחד.
- פרופילים וסטריאוטיפים. סטריאוטיפים מותאמים ו-tagged values הופכים להגדרות metadata; יש לתכנן מחדש את המשמעות שלהם.
- דיאגרמות. פריסות אינן עוברות. כל דיאגרמה חשובה הופכת לתצוגה, והתוכן שלה מנוסח מחדש עם
exposeו-filter. - התנהגויות אטומות וסקריפטים של כלים. קוד בשפת פעולה או בסקריפטים של כלי אינו מתורגם; יש לכתוב אותו מחדש או לשמור אותו מחוץ למודל.
יש לתכנן הגירה כמו כל שינוי מודל: קודם להמיר חבילה מייצגת, לסקור אותה עם האנשים שמשתמשים במודל, להחליט על דפוסי המידול לנקודות שלמעלה, ואז להמיר את השאר. יש לשמור את מודל ה-v1 כייחוס עד שמודל ה-v2 נסקר. העברת מודל SysML v1 ל-SysML v2 עובר על הצעדים האלה.
איך הרשימות נבדקו
כל רשימה בדף הזה נותחה ונבדקה עם Holarch Language Engine, המנוע שמאחורי עורך ה-SysML v2 של Holarch, כשהספרייה הסטנדרטית של SysML v2 טעונה, והיא אינה מניבה שגיאות או אזהרות. לגבי מבני SysML v2 שהמנוע תומך בהם והפערים הידועים שלו, ראו כיסוי שפת SysML v2. למודל מלא ארוך יותר, ראו את מדריך SysML v2.
לנסות ב-Holarch
ב-Holarch יש פרויקטים של SysML v2, שבהם הסימון הטקסטואלי והתצוגות עורכים מודל אחד, ופרויקטים של LML. כדי לקרוא את הרשימות שלמעלה כמודל:
- יש ליצור פרויקט SysML v2. ראו תחילת העבודה עם פרויקטים של SysML v2.
- ב-מודל ← עורך, יש ללחוץ על + חבילה חדשה ולהדביק רשימה. טקסט שמנותח בהצלחה מוחל אחרי השהיה קצרה, ובעיות מסומנות במקומן. ראו העורך.
- יש לפתוח את הרשימה דיאגרמות כדי לראות את התצוגות. ראו ההפניה לתצוגות.
מודלים של SysML v1. פרויקט SysML v2 מייבא מודל SysML 1.x ישירות: ב-מודל ← ייבוא וייצוא, יש לגרור קובץ XMI (מ-Cameo Systems Modeler או MagicDraw, Enterprise Architect, Rhapsody או Papyrus) או פרויקט .mdzip של Cameo או MagicDraw. Holarch ממיר אותו לטקסט SysML v2, בודק את הטקסט, ומציג דוח המרה שמסמן כל רכיב כהומר, קורב או הושמט, עם הסיבה, לפני שמשהו משתנה. פריסות דיאגרמה אינן מומרות, ולכן יש להתייחס לתוצאה כנקודת התחלה לחשיבה מחדש שתוארה למעלה, לא כהגירה גמורה. ראו ייבוא מודלים של SysML v1.
גם פרויקטים של LML מייבאים XMI של SysML 1.x, ומייצאים את המודל שוב כ-XMI של SysML 1.6 או כקובץ .uml של Papyrus; קובץ שנערך ב-Papyrus מיובא חזרה לאותו פרויקט ומעדכן את הפריטים במקומם לפי מזהה XMI. ראו ייבוא מודל UML/SysML והלוך ושוב עם Papyrus.
לאן ממשיכים
- מדריך SysML v2: בניית מערכת קטנה צעד אחר צעד בסימון הטקסטואלי.
- כלי SysML v2: מה לבדוק לפני שבוחרים: רשימת תיוג ומודל בדיקה לכל כלי מועמד.
- פרויקטים של SysML v2 ב-Holarch: טקסט, תצוגות ודפים הנדסיים במודל אחד.
- כיסוי שפת SysML v2: במה המנוע תומך והפערים הידועים שלו.
- החלפת מודלים של SysML v2: טקסט, JSON ומאגרי Systems Modeling API.