Leitfaden · SysML v2
SysML v1 und v2 im Vergleich: wie sich die beiden Sprachen unterscheiden
Diesen Leitfaden anhören (Audio auf Englisch) 20 min
SysML v1 und SysML v2 haben denselben Zweck und viele gemeinsame Namen, aber SysML v2 ist eine neue Sprache und keine Überarbeitung. Dieser Leitfaden vergleicht beide nebeneinander: die Grundlage, Definitionen und Usages, die textuelle Notation, Einheiten, Ports, Verhalten, Anforderungen, Ansichten, die API und was eine Migration von v1 zu v2 umfasst.
Auf dieser Seite
- Auf einen Blick
- Grundlage: ein UML-Profil gegenüber KerML
- Definitionen und Usages statt Blöcken und Properties
- Eine standardisierte textuelle Notation
- Standardbibliothek, Größen und Einheiten
- Ports, Schnittstellen und Verbindungen
- Verhalten: Aktionen und Zustände
- Anforderungen und Verification Cases
- Ansichten statt gezeichneter Diagramme
- Die Systems Modeling API und der JSON-Austausch
- Ein Modell von SysML v1 nach v2 migrieren
- Wie die Auflistungen geprüft wurden
- In Holarch ausprobieren
- Wie es weitergeht
Auf einen Blick
Wer SysML v1 kennt, erkennt die meisten Konzepte in SysML v2 wieder. Geändert hat sich, wie sie aufgebaut und wie präzise sie definiert sind. Die Tabelle fasst den Vergleich zusammen; jede Zeile hat unten ihren eigenen Abschnitt.
| Thema | SysML v1 | SysML v2 |
|---|---|---|
| Grundlage | Ein Profil von UML 2: Stereotypen auf einer Teilmenge der UML-Metaklassen | Ein eigenes Metamodell auf der Kernel Modeling Language (KerML), mit in einer formalen Bibliothek definierter Semantik |
| Struktur | Blöcke mit Part, Reference und Value Properties | Definitionen und Usages für jede Elementart: part def und part, port def und port und so weiter |
| Notation | Grafisch (neun Diagrammarten); kein Standardtext für das ganze Modell | Eine standardisierte textuelle und eine standardisierte grafische Notation für dasselbe Modell |
| Größen und Einheiten | Value Types mit Einheiten, über ein Einheitenmodell und Modellbibliotheken | ISQ-Größen und SI-Einheiten in der Standardbibliothek, direkt in Werten wie 6.5 [kg] verwendet |
| Schnittstellen | Full und Proxy Ports, Interface Blocks, Flow Properties, Item Flows an Connectors | Port-Definitionen mit gerichteten Features, Konjugation ~, Interface-Definitionen mit typisierten Enden, Flows und Binding |
| Verhalten | Aktivitäten, Zustandsautomaten und Interaktionen aus UML, über Allokation mit der Struktur verbunden | Aktionen, Zustände und Nachrichten als Occurrences, über perform und exhibit mit der Struktur verbunden |
| Anforderungen | Eine stereotypisierte Klasse mit ID und Text; Constraints liegen getrennt in Constraint Blocks | Eine Anforderung ist ein Constraint mit einem Subjekt; Text und prüfbare Bedingung in einem Element |
| Verifikation | Testfälle, über verify verknüpft | Verification Cases mit einem Ziel und einem Urteil |
| Diagramme | Zeichnungen im Besitz des Werkzeugs; Layouts wandern selten zwischen Werkzeugen | Ansichten sind Modellelemente, die angeben, was sie zeigen; das Werkzeug stellt sie dar |
| Austausch | XMI-Dateien, mit Unterschieden zwischen Werkzeugen | Textdateien, JSON und die standardisierte Systems Modeling API |
Grundlage: ein UML-Profil gegenüber KerML
SysML v1 ist als Profil von UML 2 definiert. Es nimmt eine Teilmenge von UML und fügt Stereotypen hinzu: Ein Block ist eine UML-Klasse mit dem Stereotyp «block», eine Anforderung eine Klasse mit «requirement», eine Flow Property eine Property mit «flowProperty». Das machte SysML v1 schnell einführbar, weil UML-Werkzeuge es aufnehmen konnten, bedeutete aber auch, dass Systemkonzepte an Softwarekonzepte angepasst wurden und dass die Bedeutung vieler Konstrukte aus der Semantik von UML kam, die für Software geschrieben wurde.
SysML v2 lässt die UML-Basis fallen. Es baut auf der Kernel Modeling Language (KerML) auf, einer kleineren Sprache, deren Kern in einer Bibliothek von KerML-Modellen eine präzise Bedeutung erhält. SysML v2 fügt die Systems-Engineering-Konzepte darüber hinzu: Parts, Ports, Aktionen, Zustände, Anforderungen, Cases und Ansichten. Jedes SysML-v2-Konstrukt ist als Spezialisierung von etwas in dieser Bibliothek definiert. In der Praxis bedeutet das:
- Struktur und Verhalten haben eine gemeinsame Grundlage. Parts und Aktionen sind beide Occurrences, die über die Zeit existieren, daher kann ein Part eine Aktion ausführen (perform) oder einen Zustand zeigen (exhibit), ohne eigene Allokationsebene.
- Werkzeuge stimmen enger darin überein, was ein Modell bedeutet, weil die Bedeutung in der Spezifikation und ihren Bibliotheken liegt und nicht in der Auslegung jedes Werkzeugs.
- Stereotypen sind nicht mehr der Erweiterungsmechanismus. SysML v2 verwendet Metadatendefinitionen für werkzeug- oder domänenspezifische Annotationen.
Definitionen und Usages statt Blöcken und Properties
In SysML v1 ist der Block das zentrale Element: Ein Block Definition Diagram definiert Blöcke, und ein Internal Block Diagram zeigt die Parts eines Blocks. Eine Part Property ist durch einen Block typisiert, eine Value Property durch einen Value Type. Einem Part einen anderen Wert als den Standardwert seines Blocks zu geben, etwa eine schwerere Pumpe in einer Produktvariante, erfordert eine Behelfslösung: einen spezialisierten Block, der die Property redefiniert, einen Property-spezifischen Typ oder eine Instance Specification.
SysML v2 verallgemeinert das zu einem Muster für jedes Element: Eine Definition sagt, was eine Art von Ding ist, eine Usage ist ein solches Ding in einem Kontext. Usages lassen sich verschachteln, und eine verschachtelte Usage kann das Geerbte mit einem eigenen Wert redefinieren. Dasselbe Muster gilt für Attribute, Ports, Aktionen, Zustände, Anforderungen und Ansichten.
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 in dieser Auflistung |
|---|---|
Block Pump mit Value Properties | part def Pump mit Attributen |
Generalisierung von ElectricPump zu Pump | Spezialisierung part def ElectricPump :> Pump |
Part Property pump von CoolingSystem, durch den Block typisiert | Part Usage part pump : ElectricPump |
| Ein kontextspezifischer Wert über einen spezialisierten Block oder eine Instanz | attribute redefines mass = 2.4 [kg] direkt an der Usage |
| Ein abgeleiteter Wert mit einem Constraint Block und einem Parametric Diagram | totalMass als Ausdruck am Attribut |
:>> ist die Kurzform von redefines. Reference Properties in v1, die auf ein anderswo besessenes Part zeigen, werden in v2 zu ref-Usages.
Eine standardisierte textuelle Notation
SysML v1 hat keine standardisierte Textform für ein ganzes Modell. Das Modell liegt im Repository des Werkzeugs, man arbeitet in Diagrammen, und Dateien wandern als XMI zwischen Werkzeugen, das für Maschinen gedacht ist, nicht zum Lesen. Text erscheint nur an einzelnen Stellen: in Constraint-Ausdrücken, Opaque Behaviors und in manchen Werkzeugen in Aktionssprachen.
SysML v2 hat eine textuelle Notation, die die ganze Sprache abdeckt, neben einer grafischen Notation. Beide zeigen dasselbe Modell. Jede Auflistung auf dieser Seite ist diese textuelle Notation; das SysML-v2-Tutorial baut darin Schritt für Schritt ein vollständiges Modell auf. Text verändert die Arbeitsweise eines Teams:
- Ein Modell lässt sich Zeile für Zeile prüfen, mit einem Diff vergleichen und zusammen mit den übrigen Engineering-Daten unter Versionskontrolle halten.
- Ingenieure können ein Modell schnell tippen, Muster zwischen Modellen kopieren und Teile davon mit Skripten erzeugen.
- Ein Modell lässt sich wie Quellcode prüfen: Nicht aufgelöste Namen, falsche Einheiten und unpassende Ports werden dort gemeldet, wo sie auftreten.
Die textuelle Notation ersetzt Diagramme nicht. Sie macht das Modell zum primären Artefakt, und Diagramme werden zu Ansichten davon, wie unten beschrieben.
Standardbibliothek, Größen und Einheiten
SysML v1 typisiert eine Value Property durch einen Value Type, der eine Einheit und eine Größenart tragen kann. Die Spezifikation enthält ein Modell für Größen und Einheiten sowie Modellbibliotheken für gängige Einheiten, aber Werkzeuge unterscheiden sich darin, welche Bibliotheken sie mitliefern und wie weit sie Einheiten in Ausdrücken prüfen.
SysML v2 liefert eine Standardbibliothek als Teil der Sprache mit. Sie enthält das Internationale Größensystem (ISQ), SI-Einheiten (SI), US-übliche Einheiten, skalare Typen, Collections und die Standard-View-Definitionen. In der obigen Auflistung:
attribute mass : MassValuesagt, dass das Attribut eine Masse ist, keine Zahl.6.5 [kg]ist ein Größenwert: eine Zahl mit Einheit, inline geschrieben.pump.mass + radiator.massaddiert zwei Massen. Ein Werkzeug, das Einheiten auswertet, kann einen Ausdruck zurückweisen, der eine Masse zu einer Leistung addiert, oder eine Masse, die in Volt angegeben ist.
Ports, Schnittstellen und Verbindungen
Ports durchliefen in SysML v1 mehrere Entwürfe. Frühe Versionen hatten Standard Ports und Flow Ports; spätere ersetzten sie durch Full Ports, Proxy Ports und Interface Blocks mit Flow Properties. Eine Flow Property hat eine Richtung (in, out oder inout), ein Port kann konjugiert werden, um die Richtungen umzukehren, und Item Flows an Connectors sagen, was sich bewegt. Viele bestehende v1-Modelle mischen noch die älteren und neueren Port-Arten.
SysML v2 behält die Ideen bei und vereinheitlicht sie. Eine Port-Definition listet gerichtete Features, die empfangende Seite verwendet die Konjugation ~ derselben Definition, und eine Interface-Definition beschreibt eine Art von Verbindung mit typisierten Enden.
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 mit Flow Properties | port def mit in-, out- oder inout-Features |
| Proxy oder Full Port, durch den Interface Block typisiert | port-Usage, durch die Port-Definition typisiert |
| Konjugierter Port-Typ | ~CoolantPort |
| Connector, optional durch einen Association Block typisiert | connect … to … oder eine interface-Usage, durch eine interface def typisiert |
| Binding Connector | bind a = b |
| Item Flow an einem Connector | flow-Usage oder ein Item-Feature des Ports |
Weil die Richtungen Teil der Definitionen sind, kann ein Prüfer warnen, wenn beide Enden einer Verbindung dasselbe Feature senden und keines es empfängt.
Loop aus der Auflistung in einer Interconnection View, der SysML-v2-Entsprechung eines Internal Block Diagram.Verhalten: Aktionen und Zustände
SysML v1 übernimmt sein Verhalten von UML: Aktivitäten mit Token-Flow-Semantik, Zustandsautomaten und Interaktionen für Sequenzdiagramme. Ein Verhalten wird über Allokation mit der Struktur verbunden, die es ausführt, oft mit Activity Partitions (Swimlanes) oder «allocate»-Beziehungen.
In SysML v2 sind Aktionen und Zustände Occurrences, wie Parts. Eine Action-Definition hat Eingangs- und Ausgangsparameter; Successions (first … then …) geben die Reihenfolge an, und Flows sagen, was zwischen den Schritten übergeht. Eine State-Definition hat Zustände und Transitionen mit Triggern, Guards und Effekten. Ein Part führt eine Aktion mit perform aus und zeigt einen Zustand mit exhibit, sodass die Verbindung zur Struktur Teil der Sprache ist und keine zusätzliche Beziehung.
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 |
|---|---|
| Aktivität mit Aktionen, Control Flows und Object Flows | action def mit Action Usages, Successions und flows |
| Fork-, Join-, Decision- und Merge-Knoten | fork, join, decide und merge |
| Call Behavior Action | Eine Action Usage, typisiert durch eine andere Action-Definition |
| Partition oder «allocate» von der Aktivität zum Block | perform im Part |
| Zustandsautomat im Besitz eines Blocks | state def, mit exhibit state im Part |
| Transition mit Trigger, Guard und Effekt | transition … accept … if … do … then … |
| Interaktion (Sequenzdiagramm) | Occurrences mit messages, in einer Sequence View gezeigt |
PumpModes in einer State Transition View, aus dem obigen Text gezeichnet.Anforderungen und Verification Cases
Eine SysML-v1-Anforderung ist eine stereotypisierte Klasse mit zwei Zeichenketten: einer ID und einem Text. Beziehungen verbinden sie mit dem Rest des Modells: satisfy, verify, derive, refine, trace und copy. Ein Testfall ist ein mit «testCase» markiertes Verhalten. Eine Anforderung mit Zahlen zu prüfen erfordert einen eigenen Constraint Block in einem Parametric Diagram, und nichts in der Sprache bindet diesen Constraint an den Text der Anforderung.
In SysML v2 ist eine Requirement-Definition eine Art Constraint-Definition. Sie hat ein Subjekt (worum es in der Anforderung geht), kann Attribute wie einen Grenzwert haben und enthält die Bedingung, die gelten muss. Der doc-Text und die Bedingung stehen in einem Element. Ein Verification Case nennt in seinem Ziel die Anforderung, die er verifiziert, und liefert ein Urteil.
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'>ist ein Kurzname, der Platz der v1-Anforderungs-ID in v2.require constraintist die prüfbare Form des Texts. Bei 18 kW gegenüber 15 kW meldet ein Werkzeug, das Constraints auswertet, die Anforderung als erfüllt.satisfyundverifybehalten ihre v1-Bedeutung. Derive, refine und trace werden zu Abhängigkeiten oder zu Requirement Usages, die in anderen Anforderungen verschachtelt sind; Teams entscheiden, wie sie diese modellieren.- SysML v2 ergänzt Anforderungen um Annahmen (
assume constraint), Stakeholder und Concerns sowie Use Cases und Analysis Cases neben den Verification Cases.
Ansichten statt gezeichneter Diagramme
Ein SysML-v1-Diagramm ist eine Zeichnung im Besitz des Werkzeugs: Jemand wählt, welche Elemente wo erscheinen. Zwei Diagramme desselben Blocks können sich darüber widersprechen, was er enthält, und Diagrammlayouts überstehen einen Austausch zwischen Werkzeugen selten. Spätere v1-Versionen fügten Views und Viewpoints hinzu, aber sie werden meist für Dokumente verwendet, nicht für die Diagramme, die Ingenieure täglich zeichnen.
In SysML v2 ist eine Ansicht ein Element des Modells. Sie nennt mit expose, was gezeigt wird, mit filter, welche Elementarten enthalten sind, und welche Standard-View-Definition sie darstellt. Das Layout bleibt dem Werkzeug überlassen; was die Ansicht enthält, steht im Modell und lässt sich im Text lesen.
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-Diagramm | SysML-v2-Ansicht |
|---|---|
| Block Definition, Package, Requirement Diagram | General View, mit Filtern |
| Internes Blockdiagramm | Interconnection View |
| Aktivitätsdiagramm | Action Flow View |
| Zustandsautomatendiagramm | State Transition View |
| Sequenzdiagramm | Sequence View |
| Parametrisches Diagramm | General oder Interconnection View der Constraints und ihrer Bindings |
| Anwendungsfalldiagramm | General View der Use Cases und Akteure |
| Tabellen und Matrizen (in v1 werkzeugspezifisch) | Grid View |
Die Systems Modeling API und der JSON-Austausch
SysML-v1-Modelle wandern als XMI zwischen Werkzeugen. XMI ist ein Standard, aber jedes Werkzeug schreibt eine eigene Variante, eigene Stereotypen und Diagrammdaten, daher muss ein Austausch meist pro Werkzeugpaar getestet werden, und es gibt keinen standardisierten Weg, wie ein Programm ein Modell in einem anderen Werkzeug abfragen kann.
SysML v2 kommt mit der Spezifikation Systems Modeling API and Services. Sie definiert Dienste für Projekte, Branches, Commits, Elemente und Abfragen sowie eine REST/HTTP-Anbindung, in der jedes Element ein JSON-Objekt mit @id und @type ist. Die Folgen:
- Ein Skript, ein Dashboard oder ein anderes Werkzeug kann ein Modell über eine dokumentierte Schnittstelle lesen und abfragen statt über eine herstellerspezifische.
- Element-IDs wandern mit dem Modell, sodass Links zwischen Werkzeugen einen Austausch überstehen können.
- Modelle werden als Commits auf Branches versioniert, ähnlich wie Quellcode.
Textdateien und JSON ergänzen sich: Text ist zum Lesen, Prüfen und Vergleichen für Menschen; JSON behält die IDs, auf die sich Werkzeuge stützen.
Ein Modell von SysML v1 nach v2 migrieren
Ein v1-Modell nach v2 zu bringen ist eine Übersetzung zwischen Sprachen, kein Datei-Upgrade, und das Zielwerkzeug entscheidet, wie viel davon automatisiert ist: Was bei einem SysML-v2-Werkzeug zu prüfen ist behandelt den v1-Import neben den anderen Prüfungen. Ein großer Teil eines typischen Modells lässt sich direkt abbilden, und manches wird besser auf v2-Art neu aufgebaut als wörtlich übersetzt.
Was sich sauber abbilden lässt
- Pakete und ihre Verschachtelung.
- Blöcke zu Part-Definitionen, Part Properties zu Part Usages, Reference Properties zu
ref-Usages, Generalisierungen zu Spezialisierungen. - Value Properties zu Attributen, mit Größen und Einheiten, wenn die v1-Value-Types Einheiten hatten.
- Interface Blocks mit Flow Properties zu Port-Definitionen; Proxy und Full Ports zu Port Usages; Connectors zu Connections oder Interfaces.
- Anforderungs-IDs und -Text zu Kurznamen und
doc; satisfy- und verify-Beziehungen. - Zustandsautomaten zu State-Definitionen; gut strukturierte Aktivitäten zu Action-Definitionen mit Successions und Flows.
Was ein Umdenken erfordert
- Kontextspezifische Werte. Property-spezifische Typen, Instance Specifications und Redefinitionen, die nur zum Setzen eines Werts angelegt wurden, werden zu einfachen Redefinitionen an Usages. Eine wörtliche Übersetzung behält die Behelfslösung.
- Reine Textanforderungen. v2 erlaubt sie, aber der Gewinn entsteht durch das Hinzufügen der Bedingung. Entscheiden Sie, welche Anforderungen einen
require constrainterhalten. - Constraint Blocks und Parametric Diagrams. Sie werden zu Constraint- und Calculation-Definitionen, oft direkt als Ausdrücke an Attributen geschrieben, wie
totalMassoben. - Allokation. Activity Partitions und «allocate»-Beziehungen vom Verhalten zur Struktur werden zu
performundexhibit, wo die Bedeutung „dieses Part tut das“ ist. - Ältere Port-Arten. Standard und Flow Ports aus frühen v1-Modellen brauchen die meiste Arbeit, da v2 ein einziges Port-Konzept hat.
- Profile und Stereotypen. Eigene Stereotypen und Tagged Values werden zu Metadatendefinitionen; ihre Bedeutung muss neu entworfen werden.
- Diagramme. Layouts werden nicht übernommen. Jedes wichtige Diagramm wird zu einer Ansicht, und sein Inhalt wird mit
exposeundfilterneu formuliert. - Opaque Behaviors und Werkzeugskripte. Code in einer Aktionssprache oder in der Skriptsprache eines Werkzeugs lässt sich nicht übersetzen; er muss neu geschrieben oder außerhalb des Modells gehalten werden.
Planen Sie eine Migration wie jede Modelländerung: Konvertieren Sie zuerst ein repräsentatives Paket, prüfen Sie es mit den Anwendern des Modells, legen Sie die Modellierungsmuster für die obigen Punkte fest und konvertieren Sie dann den Rest. Behalten Sie das v1-Modell als Referenz, bis das v2-Modell geprüft ist. Ein SysML-v1-Modell nach SysML v2 bringen führt durch diese Schritte.
Wie die Auflistungen geprüft wurden
Jede Auflistung auf dieser Seite wurde mit der Holarch Language Engine geparst und geprüft, der Engine hinter dem SysML-v2-Editor von Holarch, mit geladener SysML-v2-Standardbibliothek, und ergibt keine Fehler und keine Warnungen. Welche SysML-v2-Konstrukte die Engine unterstützt und welche Lücken bekannt sind, zeigt die Sprachabdeckung von SysML v2. Ein längeres durchgearbeitetes Modell bietet das SysML-v2-Tutorial.
In Holarch ausprobieren
Holarch hat SysML-v2-Projekte, in denen die textuelle Notation und die Ansichten ein Modell bearbeiten, und LML-Projekte. So lesen Sie die obigen Auflistungen als Modell:
- Legen Sie ein SysML-v2-Projekt an. Siehe Erste Schritte mit SysML-v2-Projekten.
- Klicken Sie unter Modell → Editor auf + Neues Package und fügen Sie eine Auflistung ein. Text, der sich parsen lässt, wird nach einer kurzen Pause übernommen, und Probleme werden an Ort und Stelle markiert. Siehe den Editor.
- Öffnen Sie die Liste Diagramme, um die Ansichten zu sehen. Siehe die Referenz zu Ansichten.
SysML-v1-Modelle. Ein SysML-v2-Projekt importiert ein SysML-1.x-Modell direkt: Ziehen Sie unter Modell → Import und Export eine XMI-Datei (aus Cameo Systems Modeler oder MagicDraw, Enterprise Architect, Rhapsody oder Papyrus) oder ein Cameo- bzw. MagicDraw-Projekt .mdzip hinein. Holarch konvertiert es in SysML-v2-Text, prüft den Text und zeigt einen Konvertierungsbericht, der jedes Element als konvertiert, angenähert oder ausgelassen markiert, mit Grund, bevor sich etwas ändert. Diagrammlayouts werden nicht konvertiert, betrachten Sie das Ergebnis also als Ausgangspunkt für das oben beschriebene Umdenken, nicht als fertige Migration. Siehe SysML-v1-Modelle importieren.
LML-Projekte importieren ebenfalls SysML-1.x-XMI und exportieren das Modell wieder als SysML-1.6-XMI oder als Papyrus-Datei .uml; eine in Papyrus bearbeitete Datei lässt sich zurück in dasselbe Projekt importieren und aktualisiert die Elemente an Ort und Stelle über die XMI-ID. Siehe ein UML/SysML-Modell importieren und Round Trip mit Papyrus.
Wie es weitergeht
- SysML-v2-Tutorial: ein kleines System Schritt für Schritt in der textuellen Notation aufbauen.
- SysML-v2-Werkzeuge: was vor der Auswahl zu prüfen ist: eine Checkliste und ein Testmodell für jedes infrage kommende Werkzeug.
- SysML-v2-Projekte in Holarch: Text, Ansichten und Engineering-Seiten auf einem Modell.
- Sprachabdeckung von SysML v2: was die Engine unterstützt und ihre bekannten Lücken.
- SysML-v2-Modelle austauschen: Text, JSON und Repositories der Systems Modeling API.