Seminar Eclipse Capella Intensivseminar: Erweiterung, Automatisierung und Dokumentation

Das Intensivformat bündelt Anforderungen, Eigenschaften, Dokumentgenerierung, Python-Automatisierung und Capella-Studio-Erweiterungen. Die Themen werden so verdichtet, dass passende Techniken ausgewählt und in einem integrierten Werkzeugkonzept kombiniert werden können.

Inhaltsübersicht

1. Zielsetzung
2. Zielgruppe
3. Voraussetzungen
4. Seminarinhalte
5. Praxisübungen
6. Lernorganisation
7. Einordnung im Lernpfad

Zielsetzung

Ziel ist ein belastbarer Lösungsentwurf für Erweiterung und Integration mit funktionsfähigen Prototypen für Daten, Skripte, Dokumente und Viewpoints.

Zielgruppe

Toolentwickler, Automatisierungsingenieure, MBSE-Plattformentwickler, Dokumentationsverantwortliche und technisch erfahrene Modellierende.

Voraussetzungen

Sichere Capella-Kenntnisse, Python-Grundlagen und grundlegende Java-/Eclipse-Kenntnisse.

Seminarinhalte

1. Anforderungen über ReqIF importieren und pflegen

1. Schritt 1: Anforderungstypen, Attribute und Hierarchien der Ausgangsdaten prüfen.
2. Schritt 2: ReqIF-Daten in den Requirements Viewpoint importieren und Mapping kontrollieren.
3. Schritt 3: Änderungsimporte differenzbasiert ausführen und Konflikte bewerten.
4. Schritt 4: Anforderungen nach Typ, Status und Verantwortlichkeit für die Modellarbeit strukturieren.

2. Anforderungen mit Architekturartefakten rückverfolgbar verknüpfen

1. Schritt 1: Traceability-Ziele und zulässige Beziehungstypen für das Projekt festlegen.
2. Schritt 2: Anforderungen mit Fähigkeiten, Funktionen, Komponenten, Schnittstellen und Szenarien verknüpfen.
3. Schritt 3: Abdeckungsmatrizen erstellen und fehlende beziehungsweise mehrdeutige Zuordnungen analysieren.
4. Schritt 4: Änderungsauswirkungen entlang der Beziehungen bewerten und dokumentieren.

3. Spezifische Eigenschaften mit PVMT definieren

1. Schritt 1: Projektbezogene Eigenschaftsgruppen, Datentypen und Gültigkeitsbereiche festlegen.
2. Schritt 2: PVMT-Konfiguration auf passende Arcadia-Konzepte anwenden.
3. Schritt 3: Werte konsistent erfassen und mit fachlichen Regeln plausibilisieren.
4. Schritt 4: Eigenschaften für Auswertungen, Dokumentation und Architekturvergleiche vorbereiten.

4. Eigenschaften auswerten und Diagramme regelbasiert gestalten

1. Schritt 1: Darstellungsregeln aus Eigenschaftswerten und Reviewzielen ableiten.
2. Schritt 2: Diagram Styler konfigurieren und Abhängigkeiten zum Modell dokumentieren.
3. Schritt 3: Architekturalternativen nach Eigenschaften filtern und visuell vergleichen.
4. Schritt 4: Darstellung auf Eindeutigkeit, Aktualität und Fehlinterpretationsrisiken prüfen.

5. M2Doc-Vorlagen und Dokumentstruktur aufbauen

1. Schritt 1: Dokumentziel, Zielgruppen und benötigte Modellinformationen festlegen.
2. Schritt 2: Word-Vorlage mit Abschnitten, Formatvorlagen und Platzhaltern vorbereiten.
3. Schritt 3: M2Doc-Ausdrücke für Texte, Tabellen und Diagramme schrittweise einfügen.
4. Schritt 4: Vorlage gegen unterschiedliche Modellstände testen und stabilisieren.

6. Abfragen, Schleifen und robuste Dokumentgenerierung entwickeln

1. Schritt 1: Modellzugriffe mit geeigneten Diensten und AQL-Ausdrücken formulieren.
2. Schritt 2: Sammlungen filtern, sortieren und in Tabellen oder Abschnitten ausgeben.
3. Schritt 3: Fehlende Werte, leere Listen und optionale Diagramme defensiv behandeln.
4. Schritt 4: Generierung reproduzierbar ausführen und Ausgabe auf Vollständigkeit prüfen.

7. Python4Capella einrichten und Modelle lesen

1. Schritt 1: Skriptumgebung, API-Dokumentation und Beispielskripte strukturiert vorbereiten.
2. Schritt 2: Aktives Modell öffnen und zentrale Arcadia-Objekte über die Python-API finden.
3. Schritt 3: Hierarchien, Beziehungen und Eigenschaften sicher durchlaufen.
4. Schritt 4: Ausnahmen, leere Ergebnisse und unterschiedliche Modellzustände robust behandeln.

8. Auswertungen und Exporte automatisieren

1. Schritt 1: Auswertungsziel und benötigte Modellabfragen in kleine Funktionen zerlegen.
2. Schritt 2: Daten filtern, aggregieren und für CSV- oder Tabellenexport aufbereiten.
3. Schritt 3: Qualitätskennzahlen und Traceability-Lücken automatisch bestimmen.
4. Schritt 4: Skriptausführung protokollieren und Ergebnisse gegen manuelle Stichproben prüfen.

9. Modelle kontrolliert mit Python verändern

1. Schritt 1: Schreiboperationen, Transaktionen und zulässige Objektänderungen vorbereiten.
2. Schritt 2: Neue Elemente mit eindeutigen Namen und korrektem Container anlegen.
3. Schritt 3: Beziehungen setzen, vorhandene Elemente aktualisieren und Duplikate vermeiden.
4. Schritt 4: Änderungen validieren, speichern und mit einem Rücksetzverfahren absichern.

10. Capella Studio und Entwicklungsumgebung einrichten

1. Schritt 1: Passende Capella-Studio-Version, Java-Umgebung und Workspace-Struktur festlegen.
2. Schritt 2: Target Platform und benötigte Plug-in-Projekte erzeugen.
3. Schritt 3: Laufzeitinstanz starten und Entwicklungs- von Anwenderumgebung trennen.
4. Schritt 4: Fehlerprotokolle, Plug-in-Abhängigkeiten und Buildzustand systematisch prüfen.

11. Metamodellerweiterungen und Domänenkonzepte entwickeln

1. Schritt 1: Fachliche Erweiterungsanforderungen in Klassen, Attribute und Beziehungen übersetzen.
2. Schritt 2: Ecore-Modell mit Namensräumen, Vererbung und Kardinalitäten definieren.
3. Schritt 3: Generierten Code und Persistenzverhalten kontrollieren.
4. Schritt 4: Kompatibilität mit Capella-Kernmodell und Migrationsanforderungen prüfen.

12. Viewpoint, Benutzeroberfläche und Diagramme erweitern

1. Schritt 1: Viewpoint-Lebenszyklus, Aktivierung und Gültigkeitsbereich festlegen.
2. Schritt 2: Eigenschaftsansichten, Aktionen und semantische Regeln modellieren.
3. Schritt 3: Diagramme, Werkzeuge und Darstellungsregeln in Sirius konfigurieren.
4. Schritt 4: Bedienbarkeit und Modellkonsistenz in einer Runtime-Instanz testen.

13. Erweiterungen testen, paketieren und warten

1. Schritt 1: Funktionale Tests, Kompatibilitätstests und Migrationsfälle definieren.
2. Schritt 2: Feature, Update Site und Produktabhängigkeiten für die Verteilung konfigurieren.
3. Schritt 3: Installation und Deinstallation in einer sauberen Anwenderumgebung prüfen.
4. Schritt 4: Versionierung, Änderungsdokumentation und Wartungsstrategie festlegen.

Praxisübungen

• Einen kleinen ReqIF-Bestand importieren, aktualisieren und auf Attributverluste prüfen.
• Eine Anforderungsmenge auf Systemfunktionen und Architekturkomponenten abbilden und Lücken auswerten.
• Ein Eigenschaftsmodell für Kosten, Masse und Kritikalität anlegen und auf Modellobjekte anwenden.
• Ein Diagramm anhand von Kritikalität und Reifegrad automatisch kennzeichnen.
• Eine kompakte Architekturbeschreibung aus einer selbst erstellten M2Doc-Vorlage erzeugen.
• Eine mehrstufige Tabelle mit Funktionen, Komponenten und Schnittstellen automatisch erzeugen.
• Ein Skript erstellen, das Funktionen und zugeordnete Komponenten strukturiert ausliest.
• Einen automatisierten Bericht zu unzugeordneten Funktionen und Schnittstellen erzeugen.

Lernorganisation

Kleine Prototypen werden schrittweise zu einem integrierten Werkzeugkonzept verbunden. Der Schwerpunkt liegt auf Auswahlentscheidung, Schnittstellen und Wartbarkeit, nicht auf maximaler Tiefe jedes Einzelwerkzeugs.

Einordnung im Lernpfad

Deckt die Einzelseminare zu Requirements und ReqIF, PVMT, M2Doc, Python4Capella und Capella Studio in verdichteter Form ab.