Holarch

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
  1. Auf einen Blick
  2. Grundlage: ein UML-Profil gegenüber KerML
  3. Definitionen und Usages statt Blöcken und Properties
  4. Eine standardisierte textuelle Notation
  5. Standardbibliothek, Größen und Einheiten
  6. Ports, Schnittstellen und Verbindungen
  7. Verhalten: Aktionen und Zustände
  8. Anforderungen und Verification Cases
  9. Ansichten statt gezeichneter Diagramme
  10. Die Systems Modeling API und der JSON-Austausch
  11. Ein Modell von SysML v1 nach v2 migrieren
    1. Was sich sauber abbilden lässt
    2. Was ein Umdenken erfordert
  12. Wie die Auflistungen geprüft wurden
  13. In Holarch ausprobieren
  14. 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.

ThemaSysML v1SysML v2
GrundlageEin Profil von UML 2: Stereotypen auf einer Teilmenge der UML-MetaklassenEin eigenes Metamodell auf der Kernel Modeling Language (KerML), mit in einer formalen Bibliothek definierter Semantik
StrukturBlöcke mit Part, Reference und Value PropertiesDefinitionen und Usages für jede Elementart: part def und part, port def und port und so weiter
NotationGrafisch (neun Diagrammarten); kein Standardtext für das ganze ModellEine standardisierte textuelle und eine standardisierte grafische Notation für dasselbe Modell
Größen und EinheitenValue Types mit Einheiten, über ein Einheitenmodell und ModellbibliothekenISQ-Größen und SI-Einheiten in der Standardbibliothek, direkt in Werten wie 6.5 [kg] verwendet
SchnittstellenFull und Proxy Ports, Interface Blocks, Flow Properties, Item Flows an ConnectorsPort-Definitionen mit gerichteten Features, Konjugation ~, Interface-Definitionen mit typisierten Enden, Flows und Binding
VerhaltenAktivitäten, Zustandsautomaten und Interaktionen aus UML, über Allokation mit der Struktur verbundenAktionen, Zustände und Nachrichten als Occurrences, über perform und exhibit mit der Struktur verbunden
AnforderungenEine stereotypisierte Klasse mit ID und Text; Constraints liegen getrennt in Constraint BlocksEine Anforderung ist ein Constraint mit einem Subjekt; Text und prüfbare Bedingung in einem Element
VerifikationTestfälle, über verify verknüpftVerification Cases mit einem Ziel und einem Urteil
DiagrammeZeichnungen im Besitz des Werkzeugs; Layouts wandern selten zwischen WerkzeugenAnsichten sind Modellelemente, die angeben, was sie zeigen; das Werkzeug stellt sie dar
AustauschXMI-Dateien, mit Unterschieden zwischen WerkzeugenTextdateien, 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 v1SysML v2 in dieser Auflistung
Block Pump mit Value Propertiespart def Pump mit Attributen
Generalisierung von ElectricPump zu PumpSpezialisierung part def ElectricPump :> Pump
Part Property pump von CoolingSystem, durch den Block typisiertPart Usage part pump : ElectricPump
Ein kontextspezifischer Wert über einen spezialisierten Block oder eine Instanzattribute redefines mass = 2.4 [kg] direkt an der Usage
Ein abgeleiteter Wert mit einem Constraint Block und einem Parametric DiagramtotalMass 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 : MassValue sagt, dass das Attribut eine Masse ist, keine Zahl.
  • 6.5 [kg] ist ein Größenwert: eine Zahl mit Einheit, inline geschrieben.
  • pump.mass + radiator.mass addiert 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 v1SysML v2
Interface Block mit Flow Propertiesport def mit in-, out- oder inout-Features
Proxy oder Full Port, durch den Interface Block typisiertport-Usage, durch die Port-Definition typisiert
Konjugierter Port-Typ~CoolantPort
Connector, optional durch einen Association Block typisiertconnect … to … oder eine interface-Usage, durch eine interface def typisiert
Binding Connectorbind a = b
Item Flow an einem Connectorflow-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.

Der 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 v1SysML v2
Aktivität mit Aktionen, Control Flows und Object Flowsaction def mit Action Usages, Successions und flows
Fork-, Join-, Decision- und Merge-Knotenfork, join, decide und merge
Call Behavior ActionEine Action Usage, typisiert durch eine andere Action-Definition
Partition oder «allocate» von der Aktivität zum Blockperform im Part
Zustandsautomat im Besitz eines Blocksstate def, mit exhibit state im Part
Transition mit Trigger, Guard und Effekttransition … 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 constraint ist die prüfbare Form des Texts. Bei 18 kW gegenüber 15 kW meldet ein Werkzeug, das Constraints auswertet, die Anforderung als erfüllt.
  • satisfy und verify behalten 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-DiagrammSysML-v2-Ansicht
Block Definition, Package, Requirement DiagramGeneral View, mit Filtern
Internes BlockdiagrammInterconnection View
AktivitätsdiagrammAction Flow View
ZustandsautomatendiagrammState Transition View
SequenzdiagrammSequence View
Parametrisches DiagrammGeneral oder Interconnection View der Constraints und ihrer Bindings
AnwendungsfalldiagrammGeneral 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 constraint erhalten.
  • Constraint Blocks und Parametric Diagrams. Sie werden zu Constraint- und Calculation-Definitionen, oft direkt als Ausdrücke an Attributen geschrieben, wie totalMass oben.
  • Allokation. Activity Partitions und «allocate»-Beziehungen vom Verhalten zur Struktur werden zu perform und exhibit, 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 expose und filter neu 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:

  1. Legen Sie ein SysML-v2-Projekt an. Siehe Erste Schritte mit SysML-v2-Projekten.
  2. 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.
  3. Ö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