Holarch

Leitfaden · SysML v2

SysML-v2-Werkzeuge: was vor der Auswahl zu prüfen ist

Diesen Leitfaden anhören (Audio auf Englisch) 16 min

Ein Evaluierungsleitfaden für SysML-v2-Werkzeuge: was bei jedem Kandidaten zu prüfen ist, wie man echte Unterstützung von einer Folie unterscheidet, eine Checklistentabelle zur Bewertung und ein kleines Testmodell, das Sie in jedes Werkzeug laden.

Auf dieser Seite
  1. Warum SysML-v2-Werkzeuge eine eigene Evaluierung brauchen
  2. Was zu prüfen ist
    1. Sprachabdeckung und wie Lücken dokumentiert sind
    2. Textuelle Notation: Bearbeiten und Prüfen
    3. Grafische Ansichten und die Synchronisierung von Text und Diagramm
    4. Standardbibliothek
    5. Die Systems Modeling API
    6. JSON-Austausch und Round Trip
    7. Migration von SysML v1
    8. Zusammenarbeit und Versionskontrolle
    9. Anforderungen und Verifikation am Modell
    10. Analyse und Auswertung mit Einheiten
    11. Bereitstellung: Cloud oder selbst gehostet
    12. Lizenzierung und Kosten
    13. Schulung
  3. Eine Evaluierungs-Checkliste
  4. Ein Testmodell für jeden Kandidaten
    1. Zwei Proben für den Prüfer
  5. Die Evaluierung durchführen
  6. Holarchs Antworten auf die Checkliste
  7. In Holarch ausprobieren
  8. Wie es weitergeht

Warum SysML-v2-Werkzeuge eine eigene Evaluierung brauchen

SysML v2 ist eine neue Sprache, keine Überarbeitung von SysML v1 (wie sich SysML v1 und v2 unterscheiden vergleicht sie im Detail). Es hat neben einer grafischen eine textuelle Notation, eine formale semantische Basis in KerML, eine Standardbibliothek mit Größen, Einheiten und Ansichtsarten und eine standardisierte API zum Lesen und Schreiben von Modellen. Ein Werkzeug kann SysML-v2-Unterstützung beanspruchen und trotzdem nur einen Teil davon abdecken, und die ausgelassenen Teile können genau die sein, von denen Ihr Programm abhängt.

Die Spezifikation ist umfangreich, und jedes Werkzeug setzt sie schrittweise um. Das ist normal. Wichtig bei einer Evaluierung ist, dass Sie wissen, welche Schritte ein Werkzeug gegangen ist, welche nicht, und ob der Hersteller es Ihnen klar sagt. Die folgenden Prüfungen gelten für jedes SysML-v2-Werkzeug, unabhängig von Preis oder Bereitstellung, und das Testmodell gibt Ihnen für jeden Kandidaten dieselbe Eingabe.

Um Kandidaten zu finden, beginnen Sie mit der Liste der SysML-v2-Werkzeuge, die die OMG führt, und der SysML-v2-Übersicht der Werkzeugfähigkeiten, die INCOSE und die OMG zur Unterstützung des Umstiegs von SysML v1 veröffentlicht haben. Beide sind Ausgangspunkte: Lesen Sie sie für Namen, dann testen Sie jedes Werkzeug selbst.

Was zu prüfen ist

Sprachabdeckung und wie Lücken dokumentiert sind

Fragen Sie nach einer Abdeckungsaussage: jeder Bereich der Sprache (Pakete, Definitionen und Usages, Spezialisierung und Redefinition, Multiplizitäten, Werte und Einheiten, Constraints, Struktur, Aktionen, Zustände, Anforderungen, Use Cases, Analysis und Verification Cases, Ansichten, Metadaten, Variabilität, Individuals und Time Slices) mit einer Stufe für jeden. Nützliche Stufen unterscheiden vier Fälle:

  • Das Werkzeug parst, prüft und verwendet das Konstrukt;
  • es tut das mit benannten Grenzen;
  • es behält das Konstrukt genau wie geschrieben, gibt ihm aber keine Bedeutung (es übersteht einen Round Trip, aber nichts prüft oder berechnet es);
  • es akzeptiert es nicht.

Mit einem Hersteller, der bekannte Lücken veröffentlicht, lässt sich leichter planen als mit einem, der nur Funktionen auflistet. Behandeln Sie „unterstützt SysML v2“ ohne Abdeckungstabelle als unbekannt und testen Sie die Konstrukte, die Ihre Modelle verwenden.

Textuelle Notation: Bearbeiten und Prüfen

In der textuellen Notation unterscheidet sich SysML v2 am stärksten von v1, und dort unterscheiden sich die Werkzeuge am stärksten. Prüfen Sie:

  • Bearbeiten: Syntaxhervorhebung, Vervollständigung von Namen und Schlüsselwörtern, Gehe zu Definition, Umbenennen im ganzen Modell, Suchen und Ersetzen.
  • Prüfen beim Tippen: Syntaxfehler sind das Minimum. Ein nützlicher Prüfer löst außerdem jeden Namen über Importe auf, meldet doppelte und mehrdeutige Namen, prüft Redefinitionen gegen das Geerbte, vergleicht Einheitendimensionen und vergleicht Port- und Flussrichtungen über Verbindungen hinweg.
  • Der Text ist das Modell: Sieht nach einer Bearbeitung jede andere Ansicht die Änderung, oder ist der Text eine Datei, die das Werkzeug ab und zu importiert?
  • Text, den das Werkzeug nicht geschrieben hat: Laden Sie Text, der von Hand oder von einem anderen Werkzeug geschrieben wurde. Kommentare, Dokumentation und Layout des Texts sollten erhalten bleiben.

Grafische Ansichten und die Synchronisierung von Text und Diagramm

In SysML v2 ist eine Ansicht ein Modellelement: Sie gibt an, was sie exponiert und filtert, und das Werkzeug stellt sie dar. Die Standardbibliothek definiert General, Interconnection, Action Flow, State Transition, Sequence und Grid Views. Prüfen Sie, welche davon das Werkzeug zeichnet, in welchen es bearbeiten kann und wie es mit dem Layout umgeht, das die Spezifikation dem Werkzeug überlässt.

Der entscheidende Test ist die Synchronisierung in beide Richtungen. Benennen Sie ein Part im Text um und sehen Sie sich jedes Diagramm an, das es zeigt. Fügen Sie in einem Diagramm eine Verbindung hinzu und lesen Sie den erzeugten Text. Ändern Sie dann beide Seiten gleichzeitig, sofern zwei Personen das können, und sehen Sie, was das Werkzeug mit dem Konflikt macht.

Standardbibliothek

Ein großer Teil der Bedeutung von SysML v2 liegt in seiner Standardbibliothek: skalare Werte, das Internationale Größensystem, SI- und US-übliche Einheiten, die Standard-View-Definitionen und die KerML-Kernelbibliotheken. Ein Werkzeug sollte die Bibliothek mitliefern, Namen gegen sie auflösen und mit ihr auswerten. Prüfen Sie, dass ISQ-Größenarten und SI-Einheiten aufgelöst werden, dass die Bibliothek nicht versehentlich geändert werden kann und welche Version der Bibliothek das Werkzeug verwendet.

Die Systems Modeling API

Die Systems Modeling API ist die standardisierte REST-Schnittstelle zu einem Modell-Repository: Projekte, Branches, Commits und Elemente. Mit ihr tauschen Werkzeuge Modelle ohne Dateien aus, und Ihre eigenen Skripte können Modelle lesen. Ein Werkzeug kann zwei Rollen übernehmen, und jede kann nur lesend sein:

  • Client: Das Werkzeug liest aus einem anderen Repository, das die API anbietet, und schreibt dorthin.
  • Server: Das Werkzeug bietet die API an, damit andere Werkzeuge seine Modelle lesen und vielleicht schreiben.

Fragen Sie, welche Rolle, welche Routen und ob Schreibzugriffe, Abfragen, Diffs und ältere Commits angeboten werden. Ein nur lesender Server ist für Berichte und zur Versorgung von Analysewerkzeugen weiterhin nützlich; er reicht nicht, wenn ein anderes Werkzeug das Modell ändern muss.

JSON-Austausch und Round Trip

Neben dem Text wandern Modelle als SysML-v2-JSON zwischen Werkzeugen: das Elementformat der API, mit einer ID für jedes Element. IDs sind wichtig: Text trägt keine, daher kann ein Werkzeug, das Text erneut importiert, Elemente nur über den Namen zuordnen, während JSON die Identität über einen Austausch hinweg bewahrt. Testen Sie einen Round Trip: aus Werkzeug A exportieren, in Werkzeug B importieren, erneut exportieren und in A importieren. Vergleichen Sie dann Elementanzahlen, Namen, Werte mit Einheiten und Beziehungen, und lesen Sie, wie jedes Werkzeug meldet, was es verworfen hat. Elementarten, die ein Werkzeug nicht unterstützt, sind die Stellen, an denen Round Trips Daten verlieren.

Migration von SysML v1

Es gibt keine verlustfreie automatische Übersetzung von v1 nach v2: Die Sprachen unterscheiden sich in der Struktur, und v1-Diagramme tragen Layout und Stereotypen ohne eindeutige Entsprechung in v2. Fragen Sie, wie das Werkzeug v1-Modelle übernimmt (meist XMI mit dem SysML-1.x-Profil), worauf es Blöcke, Parts, Ports, Aktivitäten, Zustandsautomaten und Anforderungen abbildet und ob es einen Bericht darüber erstellt, was nicht konvertiert wurde. Probieren Sie es an einem Ihrer eigenen v1-Modelle aus, nicht am Beispiel des Herstellers.

Zusammenarbeit und Versionskontrolle

Systemmodelle sind Teamarbeit. Prüfen Sie, ob mehrere Personen gleichzeitig bearbeiten können und wie Konflikte angezeigt und gelöst werden, welche Rollen es gibt (Bearbeiten, Prüfen, Ansehen), wie Historie und Baselines funktionieren und ob Sie zwei Versionen Element für Element und als Text vergleichen können. Wenn Ihre Organisation Modelle in einem Repository hält, prüfen Sie Branches, Merges und wie die eigene Versionshistorie des Werkzeugs mit den Commits des Repositorys zusammenhängt.

Anforderungen und Verifikation am Modell

SysML v2 macht eine Anforderung zu einem Constraint auf einem Subjekt, mit satisfy- und verify-Beziehungen zum Entwurf und zu den Verification Cases. Prüfen Sie, dass das Werkzeug Anforderungstext und Constraint zusammenhält, den Constraint gegen die Werte des Modells auswertet und aus den verify-Links eine Verifikationsmatrix erstellt. Prüfen Sie auch, was das Werkzeug außerhalb der Sprache hält: Anforderungsstatus, Genehmigungen, Testergebnisse und verdächtige Links nach einer Änderung. Diese sind nicht Teil des SysML-v2-Texts, fragen Sie also, wo sie gespeichert werden und ob sie mit einem Export mitwandern.

Analyse und Auswertung mit Einheiten

Jeder Wert in einem SysML-v2-Modell kann eine Einheit tragen, und Ausdrücke kombinieren sie. Prüfen Sie, dass das Werkzeug Ausdrücke mit Einheiten auswertet (eine Gesamtmasse aus drei Part-Massen, in Kilogramm), einen Dimensionsfehler als Fehler meldet und Anforderungs-Constraints gegen das Ergebnis auswertet. Prüfen Sie dann die größeren Analysefunktionen, die Sie brauchen: parametrisches Lösen, Budgets und Rollups, Trade-Studien, Simulation von Action Flows oder Zustandsautomaten. Fragen Sie, was aus dem Modell ausgewertet wird und was zusätzliche werkzeugspezifische Daten braucht.

Bereitstellung: Cloud oder selbst gehostet

Prüfen Sie, wo das Modell liegt und wer das Werkzeug betreibt: ein gehosteter Dienst, eine Desktopinstallation oder ein Server in Ihrer eigenen Umgebung. Fragen Sie bei kontrollierten oder exportbeschränkten Daten nach Selbsthosting, Datenstandort, Anmeldeoptionen und wie KI-Funktionen, falls vorhanden, konfiguriert oder abgeschaltet werden.

Lizenzierung und Kosten

Vergleichen Sie die Gesamtkosten für Ihr Team, nicht den Listenpreis pro Arbeitsplatz: Betrachter und Prüfende, akademische oder Evaluierungsnutzung, die Kosten einer API- oder Serveroption und was mit Ihren Modellen geschieht, wenn Sie nicht mehr zahlen. Prüfen Sie, ob ein Export in den Standardformaten in jedem Plan verfügbar ist, damit Ihre Modelle Ihnen gehören.

Schulung

SysML v2 ist für die meisten Ingenieure neu, auch für jene, die v1 beherrschen. Achten Sie auf Referenzdokumentation, die die Notation so abdeckt, wie das Werkzeug sie unterstützt, auf durchgearbeitete Beispiele, ein Demomodell zum Erkunden und angeleitetes Material für die eigenen Bildschirme des Werkzeugs. Sprachschulung und Werkzeugschulung sind unterschiedliche Bedürfnisse; prüfen Sie, dass beide abgedeckt sind.

Eine Evaluierungs-Checkliste

Bewerten Sie jeden Kandidaten mit denselben Fragen und derselben Eingabe. „Gezeigt“ bedeutet, dass Sie es am Testmodell oder an Ihrem eigenen Modell funktionieren sahen, nicht auf einer Folie.

BereichZu stellende FrageWie man es testet
SprachabdeckungGibt es eine veröffentlichte Abdeckungstabelle mit bekannten Lücken?Die Konstrukte suchen, die Ihre Modelle verwenden; das Testmodell laden
Textuelle NotationPrüft der Editor Namen, Redefinitionen, Einheiten und Richtungen beim Tippen?Die zwei Proben laden; jede sollte ein Problem melden
Grafische AnsichtenWelche Standardansichten werden gezeichnet und sind bearbeitbar?Eine Interconnection View und eine State Transition View des Testmodells öffnen
Synchronisierung von Text und DiagrammErscheint eine Änderung auf einer Seite sofort auf der anderen?controller im Text umbenennen; in einem Diagramm eine Verbindung hinzufügen und den Text lesen
StandardbibliothekWerden ISQ-Größen, SI-Einheiten und Standardansichten aufgelöst?Das Testmodell importiert ISQ, SI und StandardViewDefinitions
Systems Modeling APIClient, Server oder beides? Nur lesen oder lesen und schreiben?Die Elemente des Testmodells aus einem anderen Werkzeug oder mit einem Skript lesen
JSON-Round-TripBleiben Element-IDs erhalten? Was wird verworfen, und wird es gemeldet?Exportieren, in ein zweites Werkzeug importieren, erneut exportieren, vergleichen
v1-MigrationGibt es einen Importweg aus SysML v1, mit Bericht?Eines Ihrer eigenen v1-Modelle konvertieren
ZusammenarbeitGleichzeitiges Bearbeiten, Rollen, Baselines, Vergleich?Zwei Personen bearbeiten dasselbe Paket; gegen eine Baseline vergleichen
Anforderungen und VerifikationWerden Constraints ausgewertet und eine Verifikationsmatrix erstellt?Das Massenlimit auf 20 kg senken und die Anforderung scheitern sehen
Analyse mit EinheitenWerden Werte mit Einheiten ausgewertet? Was wird sonst berechnet?Prüfen, dass totalMass 23 kg ergibt
BereitstellungGehostet, Desktop, selbst gehostet?Die Optionen schriftlich erfragen, mit Datenstandort
Lizenzierung und KostenGesamtkosten für Autoren, Prüfende und Betrachter; Export in jedem Plan?Den Preis für Ihr Team ermitteln, einschließlich Prüfender
SchulungSprachreferenz, Beispiele, Werkzeugleitfäden?Einen neuen Anwender das Testsystem allein anhand der Dokumentation modellieren lassen

Ein Testmodell für jeden Kandidaten

Dieses Modell ist klein genug zum Abtippen und berührt trotzdem das meiste, was eine Evaluierung braucht: Importe aus der Standardbibliothek, Part-Definitionen und -Usages mit redefinierten Werten und Einheiten, konjugierte Ports, Verbindungen und ein Binding, einen Zustandsautomaten, eine Aktion mit Successions, zwei Anforderungen mit Constraints, ein satisfy, einen Verification Case und zwei Ansichten. Speichern Sie es als pump-station.sysml und laden Sie es in jedes Werkzeug.

Das System ist eine solarbetriebene Wasserpumpe: Ein Panel speist einen Controller, der Controller treibt die Pumpe an. Die Einheit darf nicht mehr als 25 kg wiegen, und die Spitzenleistung des Panels muss die Nennleistung der Pumpe um mindestens 20 % übersteigen. Wenn die Notation für Sie neu ist, stellt das SysML-v2-Tutorial jedes Konstrukt vor, das dieses Modell verwendet.

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

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

  port def PowerPort {
    out attribute voltage : ElectricPotentialValue;
  }

  port def WaterPort {
    out attribute pressure : PressureValue;
  }

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

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

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

  item def StartSignal;
  item def StopSignal;

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

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

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

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

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

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

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

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

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

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

  satisfy pumpSpec by pumpUnit;

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

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

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

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

Was ein Werkzeug, das diese Konstrukte unterstützt, zeigen sollte:

  • Keine Fehler und keine Warnungen. Ein Werkzeug, das hier Probleme meldet, kennt entweder ein Konstrukt nicht oder liest die Standardbibliothek anders; fragen Sie, was davon zutrifft.
  • totalMass ergibt 23 kg: 12 kg + 2 kg + 9 kg.
  • Beide Anforderungen gelten: 23 kg liegen innerhalb von 25 kg, und 400 W sind mehr als 1,2 × 300 W = 360 W.
  • unitConnections zeichnet das Panel, den Controller und die Pumpe mit ihren Ports, die beiden Verbindungen und den an die Grenze der Einheit gebundenen Auslass.
  • pumpStates zeichnet zwei Zustände mit einer Anfangstransition und zwei ausgelösten Transitionen.
  • Eine Verifikationsmatrix listet PS-1, verifiziert durch VC-1, und PS-2 ohne Verification Case.

Zwei Proben für den Prüfer

Ein Prüfer beweist seinen Wert an Fehlern. Laden Sie jede Probe für sich; jede enthält genau ein Problem.

Die erste gibt einer Leistung einen Wert in Kilogramm. Ein Werkzeug, das Dimensionen prüft, meldet einen Fehler am Wert:

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

  part def Pump {
    attribute ratedPower : PowerValue;
  }

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

Die zweite wird sauber geparst und aufgelöst, aber ihre Anforderung gilt nicht: Die Einheit wiegt 11 kg bei einem Limit von 10 kg. Ein Werkzeug, das Anforderungs-Constraints auswertet, meldet das; eines, das nur parst, akzeptiert sie stillschweigend.

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

  part def Pump {
    attribute mass : MassValue;
  }

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

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

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

Beide Proben wurden wie das Testmodell mit einer Sprach-Engine geprüft: Das Modell ergibt keine Probleme, und jede Probe ergibt genau das eine beschriebene Problem.

Die Evaluierung durchführen

  1. Schreiben Sie zuerst Ihre Anforderungen auf. Welche Konstrukte Ihre Modelle verwenden, welche Ansichten Ihre Prüfenden lesen, welche Werkzeuge Modelle austauschen müssen und wo die Daten liegen dürfen. Gewichten Sie die Zeilen der Checkliste danach.
  2. Lesen Sie die Abdeckungsaussage und die bekannten Lücken jedes Herstellers. Markieren Sie jede Zeile der Checkliste als beansprucht, nicht beansprucht oder nicht angegeben.
  3. Laden Sie das Testmodell und die Proben in jeden Kandidaten. Halten Sie fest, was jedes Werkzeug meldet, Wort für Wort.
  4. Laden Sie eines Ihrer eigenen Modelle. Ein echtes Modell findet Probleme, die kein Beispiel findet: Größe, Benennung, ungewöhnliche Konstrukte.
  5. Machen Sie einen Round Trip mit dem Werkzeug, mit dem Sie am meisten austauschen.
  6. Lassen Sie einen neuen Anwender das Testmodell allein anhand der Dokumentation des Werkzeugs aufbauen, und messen Sie die Zeit.

Bewahren Sie die Nachweise (Screenshots, exportierte Dateien, die Meldungen jedes Werkzeugs) zusammen mit den Bewertungen auf. Eine Entscheidungsaufzeichnung, die zeigt, was getestet wurde, ist für ein Review-Gremium mehr wert als eine aus Herstellermaterial kopierte Funktionsmatrix.

Holarchs Antworten auf die Checkliste

Holarch ist das Werkzeug, mit dem die Screenshots auf dieser Seite erstellt wurden, daher folgen hier seine eigenen Antworten, jeweils mit der Seite, die sie belegt. „Teilweise“ und „Noch nicht“ bedeuten, was sie sagen.

BereichStufeHolarch heute
SprachabdeckungTeilweiseEine veröffentlichte Tabelle jedes Bereichs mit Stufe, Grenzen und bekannten Lücken. Variabilität, Individuals und Time Slices, benutzerdefinierte Schlüsselwörter und semantische Metadaten werden geprüft und ausgewertet; .kerml-Dateien werden noch nicht importiert; textuelle Repräsentationen in SysML und KerML werden geprüft, andere Sprachen als Text behalten. Sprachabdeckung von SysML v2
Textuelle NotationUnterstütztEin Editor, der beim Tippen prüft (Syntax, Namen, Typisierung, Multiplizitäten, Einheiten, Richtungen, Auswertung), mit Vervollständigung, Gehe zu Definition, Umbenennen sowie Suchen und Ersetzen. Der Editor, Prüfungen
Grafische AnsichtenTeilweiseGeneral, Interconnection, Action Flow, State Transition, Sequence und Grid Views, alle bearbeitbar. Sequence Views zeichnen Nachrichten zwischen Lebenslinien und kombinierte Fragmente (alt, opt, loop und par). SysML-v2-Ansichten
Synchronisierung von Text und DiagrammUnterstütztEin Modell hinter dem Text und jeder Ansicht; eine Bearbeitung auf einer Seite erscheint auf der anderen. Text und Ansichten bleiben synchron
StandardbibliothekUnterstütztGeladen und schreibgeschützt, mit ISQ-, SI- und US-üblichen Einheiten und den Standard-View-Definitionen. Die Standardbibliothek
Systems Modeling APITeilweiseAls Client: aus einem Branch eines Repositorys, das die API anbietet, lesen und dorthin schreiben. Als Server: Andere Werkzeuge lesen das aktuelle Modell und committen in Änderungsantrags-Branches, die ein Genehmigender in Holarch anwendet. Pull und Push, Systems Modeling API
JSON-Round-TripTeilweiseImport und Export von SysML-v2-JSON mit erhaltenen Element-IDs. Elementarten, die Holarch nicht interpretiert, bleiben wie importiert erhalten und werden beim Export unverändert zurückgeschrieben. SysML-v2-Modelle austauschen
v1-MigrationTeilweiseDirekter Import eines SysML-1.x-Modells (Cameo- oder MagicDraw-.mdzip oder XMI aus Cameo, Enterprise Architect, Rhapsody oder Papyrus) in ein SysML-v2-Projekt, in SysML-v2-Text konvertiert und geprüft, mit einem Bericht darüber, was konvertiert, angenähert oder ausgelassen wurde und warum. Diagramme und ihr Layout werden nicht konvertiert. SysML-v1-Modelle importieren
ZusammenarbeitUnterstütztLive-Bearbeitung mit einem Merge Member für Member im Editor, Rollen, Baselines, die das Modell enthalten, und Vergleich nach Element und nach Pakettext. Zusammenarbeit, Baselines
Anforderungen und VerifikationUnterstütztGegen das Modell ausgewertete Anforderungs-Constraints, RVTM und Test Center aus verify-Links, Genehmigungen, TBD/TBR und zu prüfende Verknüpfungen. Anforderungen und Verifikation
Analyse mit EinheitenTeilweiseAuswertung mit Einheiten, Parametric Views, die pro Constraint eine Unbekannte lösen, Budgets, Trade-Studien und Simulation von Action Flows und Zustandsautomaten. Ein Analysis Case wird nur ausgewertet, wenn jede Eingabe einen Wert hat. Auswertung, Einheiten und Analyse
BereitstellungUnterstütztEine gehostete Web-App und auf Anfrage selbst gehostete Installationen in Ihrer eigenen Umgebung. Sicherheit, Kontakt
Lizenzierung und KostenUnterstütztEin Plan Free für Studierende, Lehrende, persönliche Projekte und individuelle Evaluierung; Unternehmen können den Plan Individual 1 Monat kostenlos testen; kostenpflichtige Pläne für kommerzielle Nutzung; kostenlose Prüfende und Betrachter in jedem Plan. Preise
SchulungTeilweiseEine Dokumentationsreferenz für jede SysML-v2-Seite, ein Schritt-für-Schritt-Tutorial, die Demo Hybrid Car, neun angeleitete SysML-v2-Tutorials in der App und eine SysML-v2-Videoreihe, die das Modell Hybrid Car aufbaut. Die Video-Trainingspfade behandeln LML-Projekte. Erste Schritte, SysML-v2-Tutorials, SysML-v2-Tutorial

In Holarch ausprobieren

  1. Speichern Sie das Testmodell als pump-station.sysml.
  2. Öffnen Sie Modell → Import und Export, wählen Sie In ein neues SysML-v2-Projekt und ziehen Sie die Datei hinein. Siehe Dateien in ein neues Projekt importieren.
  3. Öffnen Sie Modell → Editor. Die Statuszeile zeigt „Keine Probleme“, und jedes Paket ist ein Dokument.
  4. Öffnen Sie die Liste Diagramme und klicken Sie auf unitConnections oder pumpStates.
  5. Öffnen Sie Verifikation → RVTM, um die Anforderungen mit dem Case zu sehen, der sie verifiziert.
Das Testmodell im Editor, ohne Probleme.
Die Ansicht unitConnections: konjugierte Ports, zwei Verbindungen und ein Binding.
Die RVTM, aus dem verify-Link des Modells erstellt.

Wie es weitergeht