Holarch

SysML v2

Notation textuelle SysML v2

Le langage SysML v2 tel que Holarch le prend en charge, avec des exemples tirés de la démo Hybrid Car, les contrôles qu'il effectue et la bibliothèque standard en lecture seule.

Utilisation →

Sur cette page
  1. Vue d'ensemble
  2. Concepts
    1. Éléments, propriétaires et noms qualifiés
    2. Packages
    3. Imports et visibilité
    4. Définitions et usages
    5. Typage, spécialisation et redéfinition
    6. Multiplicités
    7. Valeurs et unités
    8. Structure : ports, connexions, interfaces, liaisons et flux
    9. Comportement : actions
    10. Comportement : états
    11. Exigences, contraintes et vérification
    12. Cas d'utilisation
    13. Vues
    14. Commentaires, documentation et métadonnées
    15. Individus, instantanés et tranches temporelles
    16. Variations, variantes et configurations
    17. Représentations textuelles
  3. Mode d'emploi
    1. Modéliser une structure
    2. Donner des valeurs avec des unités
    3. Décrire un comportement
    4. Écrire une exigence et la tracer
    5. Marquer une valeur comme TBD ou TBR
    6. Trouver un nom de bibliothèque
  4. Exemple commenté : lire l'exigence de la berline
  5. Conseils et erreurs courantes
  6. Ce que Holarch prend en charge
    1. Conservé tel quel, non interprété
    2. Pas encore disponible
  7. Contrôles
  8. La bibliothèque standard
  9. Limites
  10. Pages associées

Vue d'ensemble

SysML v2 décrit un système comme une arborescence d'éléments nommés, écrite sous forme de texte. Holarch prend en charge la notation textuelle SysML v2, fondée sur la spécification OMG SysML v2. Vous écrivez le texte dans l'éditeur, et Holarch affiche les mêmes éléments dans le Navigateur, les vues, les tableaux et les pages du cycle de vie.

Cette page enseigne la notation avec des exemples tirés de la démo Hybrid Car (SysML v2). Elle liste ensuite ce que Holarch prend en charge, les contrôles qu'il effectue sur votre texte et la Bibliothèque standard.

Concepts

Éléments, propriétaires et noms qualifiés

Chaque élément a un propriétaire, sauf les packages de premier niveau. Le nom qualifié d'un élément est la chaîne des noms de ses propriétaires, reliés par ::. Dans la démo, la batterie de la définition du groupe motopropulseur est Vehicles::Powertrain::battery.

Un nom contenant des espaces ou d'autres caractères spéciaux s'écrit entre apostrophes : 'Fuel Tank'. Un nom court entre chevrons donne à un élément un second identifiant, court : requirement def <'VR-1'> CurbMass. Holarch utilise le nom court d'une exigence comme numéro.

Packages

Un package regroupe des éléments, comme un dossier. Les packages peuvent s'imbriquer. Chaque package de premier niveau est un document dans l'éditeur.

package Vehicles {
    doc /* A hybrid passenger car: structure, interfaces and variants. */

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

Imports et visibilité

Un import rend les membres d'un autre package visibles par leur nom court.

  • import ISQ::*; importe les membres de ISQ.
  • import VehicleRequirements::**; importe aussi les membres des éléments imbriqués (récursif).
  • import Vehicles::Car; importe un seul élément.
  • import Vehicles::*[@SysML::PartDefinition]; n'importe que les membres d'un type (un import filtré).

private, protected et public définissent qui d'autre voit un membre ou un import. La démo écrit private import pour que les imports ne soient pas transmis aux packages qui l'importent à leur tour.

Sans import, écrivez le nom qualifié : ISQ::MassValue se résout partout, MassValue seulement là où ISQ est importé.

Un alias donne à un élément un second nom : alias Hybrid for Car;.

Définitions et usages

Une définition décrit un type de chose. Un usage est une utilisation d'une définition à l'intérieur d'un autre élément. La plupart des mots-clés existent sous les deux formes :

DéfinitionUsageCe que c'est
part def Battery;part battery : Battery;Un système, un sous-système ou un composant
attribute def TirePressure;attribute mass : MassValue = 45 [kg];Une valeur, souvent avec des unités
item def Fuel;item fuel : Fuel;Quelque chose qui circule ou qui est manipulé
port def FuelPort { … }port fuelOut : FuelPort;Un point de connexion sur une partie
connection def … / interface def FuelLine { … }interface fuel : FuelLine connect …;Un lien entre des parties ou des ports
action def ProduceTorque { … }action produce : ProduceTorque;Comportement : une étape qui reçoit des entrées et fournit des sorties
state def PowertrainStates { … }state off;Comportement : un état et ses transitions
constraint def MassLimit { … }constraint …;Une condition booléenne portant sur des valeurs
calc def PowerToWeight { … }calc …;Un calcul avec une valeur return
requirement def <'VR-1'> CurbMass { … }requirement <'VR-1.1'> sedanMass : CurbMass;Une exigence
use case def DriveToWork { … }use case commute : DriveToWork;Un cas d'utilisation
analysis def PowerToWeightAnalysis { … }analysis sedanPowerToWeight : …;Un cas d'analyse
verification def CurbMassTest { … }verification sedanWeighing : CurbMassTest;Un cas de vérification
view def RequirementsView { … }view driveCycleFlow : ActionFlowView { … }Une vue du modèle
enum def DriveMode { … }attribute mode : DriveMode;Un ensemble fixe de valeurs

Les membres imbriqués dans une définition appartiennent à chacun de ses usages. part frontAxle : Axle; possède le differential, la leftWheel et la rightWheel de Axle sans les répéter.

Typage, spécialisation et redéfinition

Quatre opérateurs relient les définitions et les usages. Chacun a aussi une forme en mot-clé.

OpérateurMot-cléSignificationExemple
:defined byType un usage par une définitionpart engine : Engine;
:> sur une définitionspecializesLa définition est une sorte de l'autre et hérite de ses membrespart def FuelTank :> Component
:> sur un usagesubsetsL'usage est un sous-ensemble d'un autre usagepart spareWheel :> wheels;
:>>redefinesRemplace un usage hérité, par exemple pour lui donner une valeurattribute redefines mass = 18 [kg];
~Conjugue un port : ses caractéristiques in et out sont permutéesport fuelIn : ~FuelPort;

La redéfinition est la façon dont une variante ou une partie configurée modifie ce dont elle hérite. Dans la démo, SportCar supprime la roue de secours par redéfinition :

part def SportCar :> Car {
    attribute topSpeed : SpeedValue = 210 [km/h];
    part redefines spare [0];
}

abstract marque une définition qui n'a pas d'instances directes (abstract part def Component). ref marque une référence qui n'est pas possédée. in, out et inout définissent la direction d'une caractéristique ou d'un paramètre. end marque les extrémités d'une définition de connexion ou d'interface.

Multiplicités

Une multiplicité entre crochets indique combien il y en a.

  • [2] : exactement deux. part runabout : CityCar [2];
  • [0..1] : facultatif. part spare : Wheel [0..1];
  • [1..*] et [*] : un ou plusieurs, nombre quelconque.
  • [0] : aucun, utilisé pour retirer une partie héritée.
  • Les bornes peuvent être des expressions. ordered et nonunique suivent les crochets.

Valeurs et unités

= lie une valeur. := donne une valeur initiale qui peut changer. default donne une valeur par défaut qu'une redéfinition peut remplacer.

attribute maxCurbMass : MassValue = 1650 [kg];
attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];
attribute minPowerToWeight = 40 [W/kg];
attribute topSpeed : SpeedValue = 210 [km/h];

Une grandeur est un nombre suivi d'une unité entre crochets. Les unités se combinent avec *, / et ^ ([m/s^2]). Les natures de grandeur telles que MassValue proviennent de ISQ, et les unités telles que kg de SI (ou de USCustomaryUnits). Holarch contrôle les dimensions : affecter 5 [s] à une MassValue est une erreur.

Les expressions utilisent l'arithmétique, la comparaison (<=, ==), les opérateurs logiques (and, or, not, implies), la conditionnelle if c ? a else b, les chaînes de caractéristiques (car.powertrain.battery.capacity), les appels de calculs (PowerToWeight(power, mass)) et les opérations sur les séquences telles que ->sum, ->size, ->select et ->collect. Holarch les évalue avec les unités pour les valeurs, les contraintes, les vues et les pages d'analyse.

Structure : ports, connexions, interfaces, liaisons et flux

Les parties se relient par leurs ports.

part def Powertrain {
    part tank : FuelTank;
    part engine : Engine;
    interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;
    connect controller.engineCtl to engine.ecu;
    port output : TorquePort;
    bind output = transmission.output;
}
  • connect a to b; relie deux parties ou deux ports.
  • Une interface est une connexion typée entre des ports. Sa définition nomme ses extrémités : interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  • Chaque extrémité d'une connexion ou d'une interface peut avoir un nom et une multiplicité : interface motorShaft : Shaft connect [1] driver ::> motor.output to [1] driven ::> transmission.motorIn;. Une extrémité nommée est une caractéristique de la connexion, donc motorShaft.driver y fait référence.
  • bind a = b; indique que deux caractéristiques sont identiques (un connecteur de liaison).
  • flow of Fuel from supply.fuel to produce.fuel; transporte un item d'une caractéristique à une autre. message envoie un item entre des parties sous forme d'événement.

Comportement : actions

Une définition d'action contient ses étapes (usages d'action), ses paramètres et l'ordre des étapes.

action def DriveCycle {
    in attribute targetSpeed : Real;
    first start then switchOn;
    action switchOn { attribute duration : DurationValue = 2 [s]; }
    then fork split;
    then supply;
    then produce;
    action supply : SupplyFuel;
    action produce : ProduceTorque;
    flow of Fuel from supply.fuel to produce.fuel;
    first supply then ready;
    first produce then ready;
    join ready;
}
  • Les successions ordonnent les étapes : first a then b;, ou then b; juste après a. start et done sont le début et la fin.
  • Nœuds de contrôle : fork et join pour les chemins parallèles ; decide et merge pour les alternatives. Une succession gardée après une décision s'écrit if speed > 30 then cruise;, et else brake; est la branche par défaut.
  • Terminate : terminate; met fin immédiatement à l'action englobante, avec toutes ses étapes encore en cours ; then terminate; le place après l'étape précédente. terminate x; met fin à l'occurrence x.
  • Autres actions : accept attend un signal, send en envoie un, assign x := expr; modifie une valeur, if exécute un bloc ou le saute, while … { … } until …; et for v in seq { … } répètent un bloc.
  • Allocation du comportement : une partie exécute une action avec perform (perform action trip : DriveCycle;, perform trip.supply;), et allocate a to b; alloue un élément à un autre.

Comportement : états

Une définition d'état contient des états et les transitions entre eux.

state def PowertrainStates {
    entry; then off;
    state off;
    accept StartRequest then hybrid;
    state hybrid {
        entry action startEngine;
        do action driveHybrid;
        exit action stopEngine;
    }
    transition recharged first hybrid if charge > 60 then electric;
}
  • entry; then off; définit l'état initial.
  • Les transitions ont un déclencheur (accept StartRequest), une garde facultative (if charge > 20) et un effet facultatif (do …). La forme courte suit l'état source ; la forme longue est transition name first a … then b;.
  • Dans le modèle, le déclencheur et l'effet d'une transition sont des éléments à part entière : une action accept et une action (send, assign, perform, terminate ou une action nommée). Le Navigateur les affiche comme trigger et effect sous la transition. Ce sont les accepter et effect propres à la transition, si bien que d'autres parties du modèle peuvent les nommer : chargerStates.plugIn.effect.sentMessage est le message que l'effet envoie, tel qu'un modèle de séquence le lie.
  • Un déclencheur passant par un port doit accepter quelque chose que le port transporte : dans le ChargeManager de la démo, accept connectCharger : ChargerConnected via chargePort correspond au in connected : ChargerConnected du port. L'effet send new ChargeRequest() to controller envoie à une partie ; une valeur telle qu'un attribut ne peut pas recevoir de message.
  • Les actions entry, do et exit s'exécutent à l'entrée dans l'état, pendant qu'il est actif et à sa sortie. Les états parallel ont des régions toutes actives en même temps.
  • Une partie présente un état avec exhibit : exhibit state powertrainStates : PowertrainStates;.

Exigences, contraintes et vérification

Une exigence contient son énoncé dans doc, l'élément auquel elle s'applique comme subject, et une condition contrôlable comme require constraint.

requirement def <'VR-1'> CurbMass {
    doc /* The car's curb mass shall not exceed the mass limit. */
    subject car : Car;
    attribute limit : MassValue;
    require constraint { car.curbMass <= limit }
}

satisfy carSpec by fleet.sedan;
  • assume constraint énonce une condition que l'exigence suppose. Lorsqu'elle n'est pas remplie, cette exigence et les exigences qui y sont imbriquées comptent comme respectées ; l'exigence qui l'entoure et les autres exigences imbriquées sont toujours contrôlées. actor, stakeholder et frame concern nomment pour qui et pour quoi est l'exigence.
  • satisfy R by part; indique qu'une partie respecte une exigence.
  • Un cas de vérification vérifie des exigences dans son objectif : objective { verify carSpec.sedanMass; }. Il peut return verdict : Boolean = …;.
  • Un cas d'analyse a un sujet, un objectif et un résultat return que Holarch évalue lorsque chaque entrée a une valeur. Les attributs du cas sans valeur sont résolus à partir des équations == de son objectif (Cas d'analyse avec inconnues).
  • connection : Derivation connect original to derived; enregistre une exigence dérivée. #refinement dependency x to R; enregistre un raffinement.
  • dependency from a to b; enregistre une trace générale.

Cas d'utilisation

use case def DriveToWork { subject car : Car; actor driver : Driver; objective { … } include use case startCar : StartCar; }. Un usage de cas d'utilisation reprend le sujet et les acteurs de sa définition.

Vues

Une vue montre une partie du modèle. Elle est typée par une définition de vue standard et expose ce qu'elle montre avec expose :

view driveCycleFlow : StandardViewDefinitions::ActionFlowView {
    expose DriveCycle;
}

filter restreint les éléments (filter @SysML::RequirementUsage;). render choisit un rendu. Un viewpoint encadre les préoccupations qu'une vue doit traiter. Vues SysML v2 explique chaque type de vue.

Commentaires, documentation et métadonnées

  • doc /* text */ documente son propriétaire. Il fait partie du modèle ; pour une exigence, c'est le texte de l'exigence.
  • comment about x /* text */ est une note dans le modèle à propos d'un autre élément.
  • // text et //* text */ sont des notes uniquement dans le texte. Holarch les conserve dans le texte, mais ce ne sont pas des éléments du modèle.
  • Les métadonnées annotent un élément : @TBD { owner = "Powertrain lead"; } dans un corps, #TBR attribute limit … en préfixe, ou metadata Capability about Vehicles::Car; depuis l'extérieur.
  • Mots-clés définis par l'utilisateur : toute définition de métadonnées fonctionne comme un mot-clé : #safetyCritical part controller : Controller; marque le contrôleur avec la métadonnée SafetyCritical (nom court <safetyCritical>). Une définition de métadonnées peut limiter ce qu'elle marque : :>> annotatedElement : SysML::PartDefinition; n'autorise que les définitions de partie.
  • Métadonnées sémantiques : une définition de métadonnées qui spécialise SemanticMetadata définit un type de base, :>> baseType = faults meta SysML::Usage;. Chaque élément qu'elle marque spécialise alors la base : un usage est un sous-ensemble d'un usage de base, une définition spécialise une définition de base ou les définitions d'un usage de base. Ainsi, #fault def BatteryOverheat; et #fault overheat : BatteryOverheat; sont des défaillances et ont les caractéristiques de Fault. Avec des métadonnées sémantiques, le mot-clé du langage peut être omis, comme dans ces deux lignes ; le Navigateur les affiche avec leur mot-clé (#fault def). Écrit depuis l'extérieur, metadata Fault about x; ne fait pas de x une défaillance : le contrôle émet un avertissement et propose de marquer x lui-même avec #fault.
  • Métadonnées ayant leur propre sens : les caractéristiques d'une définition de métadonnées sont ce que chaque utilisation doit indiquer, et ses contraintes doivent être respectées par elles. Avec metadata def SafetyRating { attribute level : Natural; assert constraint { level >= 1 and level <= 4 } }, le contrôle signale @SafetyRating; (aucun niveau) et @SafetyRating { level = 7; } (hors plage) ; @SafetyRating { level = 4; } est correct. Une caractéristique qui a une valeur ou un default dans la définition, ou qui est déclarée [0..1], peut être omise. Chaque valeur doit correspondre au type de sa caractéristique : true ou false pour un Boolean, du texte entre guillemets pour un String, un nombre entier pour un Integer (0 ou plus pour un Natural, supérieur à 0 pour un Positive), et pour une énumération l'une de ses valeurs, comme HazardAnalysis::fmea ; le contrôle signale toute autre valeur, ainsi qu'une valeur par défaut de la définition qui ne correspond pas. Un corps de métadonnées ne fait que donner des valeurs aux caractéristiques de la définition (level = 4;), et une abstract metadata def ne peut pas être appliquée. La démo Hybrid Car évalue son contrôleur avec @SafetyRating { level = 4; } et enregistre la revue de la batterie sous la forme @SafetyReview { method = HazardAnalysis::fmea; closed = true; }. Dans l'éditeur, Insérer ▾ → Définition de métadonnées commence une définition avec une caractéristique et une règle, et Appliquer des métadonnées en applique une à l'intérieur d'un corps. Sans écrire de texte : sélectionnez une définition ou un usage et utilisez la section Métadonnées de l'inspecteur. Ajouter des métadonnées applique l'une des définitions de métadonnées du projet ; chaque caractéristique a alors un champ (une liste des valeurs pour une énumération ou un Boolean, du texte simple pour un String, que Holarch écrit entre guillemets ; la valeur par défaut de la définition s'affiche comme indication, et une caractéristique sans valeur par défaut est marquée Obligatoire) ; les constats du contrôle pour ces métadonnées s'affichent en dessous ; Retirer les enlève. Chaque modification peut être défaite par une seule annulation. Les métadonnées de la bibliothèque standard et celles propres à Holarch (simulation, objectifs, variabilité) gardent leurs propres commandes et n'y sont pas listées.

Individus, instantanés et tranches temporelles

Un individu est une chose particulière sur toute sa durée de vie, comme une voiture donnée avec son numéro de série, plutôt qu'un type de chose. Un instantané est cette chose à un instant donné ; une tranche de temps est une période de sa vie. Tous deux appartiennent à l'occurrence qui les possède et ont ses caractéristiques, ce qui leur permet de donner à ces caractéristiques leurs propres valeurs.

individual part def Car_VIN1234 :> Car {
    snapshot atDelivery { attribute :>> mileage = 0 [km]; }
    timeslice firstOwner { attribute ownerName : String = "Dana Reyes"; }
    snapshot atService { attribute :>> mileage = 15000 [km]; }
    first atDelivery then atService;
    assert constraint mileageGrows { atDelivery.mileage <= atService.mileage }
}
  • individual se place avant le mot-clé du type (individual part def, individual item def) ou s'emploie seul (individual def Plate_77;). Un usage écrit individual est typé par exactement une définition individuelle : individual car1 : Car_VIN1234;.
  • snapshot et timeslice se placent avant un mot-clé de type ou s'emploient seuls, à l'intérieur d'une partie, d'un item, d'une action ou d'une autre occurrence. then timeslice secondOwner; place une tranche de temps après le membre qui la précède.
  • Une valeur à l'intérieur d'un instantané ou d'une tranche de temps est d'abord lue à cet endroit, puis dans l'individu, puis dans sa définition. Dans l'exemple, atService.mileage vaut 15 000 km et la contrainte est respectée.
  • Seules les occurrences peuvent être des individus, des instantanés ou des tranches de temps : les attributs et les énumérations sont des valeurs.
  • Dans Architecture → Parties et dans les vues Base de données et Grille, la colonne Instances liste les individus de la définition de chaque partie (pour part sedan : Car : Car_VIN1234) : les définitions individuelles qui la spécialisent et les usages individuels qu'elle type. Individuel (Oui) et Portion (Instantané ou Tranche de temps) sont aussi des colonnes (Colonnes ▾ → SysML v2). Parties affiche Instances par défaut dès que le modèle contient un individu, et l'export Tableau (CSV) inclut alors les trois colonnes ; l'export Définitions les liste pour chaque élément qui les possède.
  • Dans l'inspecteur, Occurrence sous Caractéristiques définit Individuel et, pour les usages, Vie entière, Tranche de temps ou Instantané. Le filtre de type du Navigateur propose Individus, et le menu ⋯ d'une ligne propose Nouvel instantané… et Nouvelle tranche de temps…. La vue générale affiche «individual part def», «snapshot» et «timeslice» dans les en-têtes des boîtes, liste les instantanés et tranches de temps d'une boîte dans leur propre compartiment et dessine les successions entre boîtes sous forme de flèches en pointillés ; Disposer ▾ → Disposer en chronologie les aligne de gauche à droite. Dans la démo Hybrid Car, la vue générale carLifeline montre les instantanés et la tranche de temps de Car_VIN1234.

Variations, variantes et configurations

Une variation liste les choix autorisés en un point d'une conception ; chaque choix est une variante. Une définition de variation (variation part def) est un ensemble réutilisable de choix ; un usage de variation (variation part charger) est un point à l'intérieur d'une conception. Une configuration choisit une variante pour chaque point.

variation part def BatteryPack :> Battery {
  variant part standardPack { attribute :>> capacity = 1.4 [kW*h]; }
  variant part largePack { attribute :>> capacity = 12 [kW*h]; }
}
part def CarLine :> Car {
  part pack : BatteryPack;
  variation part charger : Component {
    variant part noCharger;
    variant part wallbox;
  }
  assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }
}
part plugInHybrid : CarLine {
  @HolarchConfiguration;
  part :>> pack = BatteryPack::largePack;
  part :>> charger = charger::wallbox;
}
  • Une variante a les caractéristiques de sa variation et peut les redéfinir : largePack a une capacity parce que BatteryPack est une Battery.
  • variant x; sans mot-clé de type fait de l'usage existant x l'un des choix ; il porte le nom de x.
  • Une variation ne possède que des variantes (ainsi que des définitions, commentaires, métadonnées et imports). Une variation est déjà abstraite, donc abstract sur celle-ci est signalé comme redondant.
  • Choisissez une variante avec une valeur : part :>> pack = BatteryPack::largePack;. Un choix qui n'est pas une variante de ce point est une erreur.
  • Tant qu'un point n'a pas de choix, sa valeur est inconnue, donc une assertion qui porte sur lui n'est ni respectée ni violée. Dans une configuration, les valeurs des variantes choisies sont utilisées.
  • Marquez une configuration avec @HolarchConfiguration (package HolarchVariability, dans la bibliothèque standard sous Holarch) : l'éditeur signale alors chaque point qu'elle n'a pas encore choisi.
  • Dans l'éditeur, Insérer ▾ écrit chacun de ces éléments : Variation (une définition au niveau du package, un point à l'intérieur d'une partie), Variante (à l'intérieur d'une variation), Configuration et Choix de variante (à l'intérieur d'une configuration).
  • Dans la démo Hybrid Car, CarLine a deux points (pack et charger), et selfChargingHybrid et plugInHybrid en sont des configurations ; l'assertion exclut une wallbox avec le pack standard.

Représentations textuelles

Une représentation textuelle écrit un élément dans un autre langage : rep language "Python" /* … */ à l'intérieur du corps de l'élément. Le corps est conservé sous forme de texte. Le modèle est ce que déclare le SysML qui l'entoure ; Holarch n'exécute jamais un corps.

  • Dans la démo Hybrid Car, DriveWheels porte son calcul en Python : rep language "Python" /* wheel_speed = torque.value * GEAR_RATIOS[gear] / WHEEL_RADIUS */.
  • Un corps en "sysml" ou "kerml" est contrôlé. SpeedLimit est écrit sous la forme rep language "sysml" /* speed <= limit */, et Holarch l'évalue comme une contrainte écrite directement.
  • L'éditeur met en évidence les corps SysML et KerML comme du code sur un fond teinté. Les autres langages s'affichent comme du texte de commentaire.
  • La section Représentation de l'inspecteur liste chaque représentation avec son Langage et son corps. Cliquez sur Ajouter une représentation sur une définition ou un usage pour en ajouter une, et sur Retirer pour en supprimer une.
  • La vue de flux d'Action marque une action dont la définition a une représentation avec son langage entre accolades, par exemple {Python}.
  • Langages connus : SysML, KerML, OCL, Alf, Python, JavaScript, MATLAB, Modelica, C, langage naturel (naturalLanguage, English, text). Une version après le nom est ignorée (OCL2.0, Python 3).
  • Un corps ne peut pas contenir */, qui terminerait le commentaire.

Les commentaires de discussion, étiquettes, personnes assignées et échéances propres à Holarch sont conservés à côté du modèle. Ils ne sont pas écrits dans le texte.

Mode d'emploi

Modéliser une structure

  1. Dans l'éditeur, ouvrez un package (ou cliquez sur + Nouveau package).
  2. Écrivez une port def pour chaque type de point de connexion, avec des caractéristiques orientées (out attribute torque : TorqueValue;).
  3. Écrivez une part def pour chaque type de composant, avec ses attributs et ses ports.
  4. Écrivez une part def pour l'assemblage, avec une part pour chaque composant.
  5. Reliez les parties : connect a.p to b.q;, ou interface name : Def connect a.p to b.q;.
  6. Faites une pause. La ligne d'état indique Appliqué et le Navigateur affiche les nouveaux éléments.

Insérer ▾ (ou ⌃⇧Space / Ctrl+Shift+Space) écrit chacune de ces constructions pour vous, avec des champs à remplir. Voir Insérer une construction.

Donner des valeurs avec des unités

  1. Importez les natures de grandeur et les unités en haut du package : private import ISQ::*; et private import SI::*;.
  2. Typez l'attribut par une nature de grandeur et donnez une valeur : attribute mass : MassValue = 45 [kg];.
  3. Dans une définition qui hérite de l'attribut, redéfinissez-le avec sa propre valeur : attribute redefines mass = 18 [kg];.
  4. Pointez sur la valeur. Une carte d'erreur apparaît si l'unité ne correspond pas à la nature de grandeur.

Décrire un comportement

  1. Écrivez une action def avec ses paramètres in et out.
  2. Ajoutez une étape par usage action et ordonnez-les avec first … then …; ou then.
  3. Utilisez fork et join pour les étapes parallèles, decide et merge pour les alternatives.
  4. Ajoutez flow of Item from a.out to b.in; entre les étapes qui se transmettent des items.
  5. Dans la partie qui réalise le comportement, écrivez perform action name : Def; et, dans ses parties, perform name.step;.
  6. Ouvrez l'action dans une vue de flux d'Action pour la voir dessinée (voir Vues SysML v2).

Écrire une exigence et la tracer

  1. Écrivez requirement <'ID'> name { doc /* The system shall … */ subject s : Def; }.
  2. Ajoutez require constraint { … } lorsque l'exigence peut être contrôlée par rapport à des valeurs.
  3. Écrivez satisfy name by somePart; là où la conception la respecte.
  4. Écrivez une verification dont l'objectif la vérifie avec verify.
  5. Ouvrez Besoins et exigences → Exigences : l'exigence y figure avec son numéro, et Vérification → RVTM montre comment elle est vérifiée. Voir Exigences et vérification dans les projets SysML v2.

Marquer une valeur comme TBD ou TBR

Écrire TBD à la place d'une valeur n'est pas du SysML valide. Utilisez plutôt les métadonnées de Holarch.

  1. Importez-les : private import HolarchMetadata::*;.
  2. Préfixez l'attribut : #TBD attribute chargerPower : PowerValue; (pas encore de valeur) ou #TBR attribute limit : TimeValue = 0.5 [h]; (une valeur à revoir).
  3. Pour enregistrer un responsable et une raison, écrivez la forme longue dans le corps de l'attribut : @TBD { owner = "Powertrain lead"; rationale = "The charging standard is not chosen yet."; due = "2026-12-01"; }.

Le registre TBD/TBR liste ces valeurs. TBD et TBR spécialisent ModelingMetadata::StatusInfo, de sorte que les autres outils SysML v2 les lisent comme des annotations d'état. Insérer ▾ → Valeur TBD et Valeur TBR les écrivent pour vous.

Trouver un nom de bibliothèque

  1. Ouvrez Bibliothèque standard depuis les outils du rail.
  2. Saisissez une partie du nom dans Rechercher un package ou une définition…, par exemple MassValue.
  3. Cliquez sur Copier le nom sur la ligne. Le nom qualifié, ici ISQBase::MassValue, est copié.
  4. Collez-le dans l'éditeur, ou importez son package et utilisez le nom court.

Exemple commenté : lire l'exigence de la berline

Cet exemple suit une exigence à travers le texte de la démo Hybrid Car.

  1. Ouvrez la démo et choisissez VehicleRequirements dans la liste Packages de l'éditeur.
  2. Trouvez requirement def <'VR-1'> CurbMass. Son require constraint { car.curbMass <= limit } compare la masse à vide du sujet à limit.
  3. Trouvez requirement carSpec. Elle contient requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }. L'usage redéfinit limit avec l'objectif défini au niveau du package maxCurbMass = 1650 [kg].
  4. Trouvez satisfy carSpec by fleet.sedan;. Cliquez sur sedan en maintenant ⌘ / Ctrl : l'éditeur ouvre Vehicles à part sedan : Car, où attribute redefines curbMass = 1580 [kg]; donne la valeur.
  5. De retour dans VehicleRequirements, trouvez verification def CurbMassTest. Son objectif verify carSpec.sedanMass; en fait un cas de vérification de VR-1.1, et verification sedanWeighing : CurbMassTest { subject car = fleet.sedan; } l'applique à la berline.
  6. Remplacez 1580 [kg] par 1700 [kg] dans Vehicles et faites une pause. La berline dépasse désormais la limite de 1650 kg, et l'éditeur affiche dans VehicleRequirements un avertissement indiquant que l'exigence n'est pas respectée par sedan, avec la contrainte fausse et ses valeurs. Annulez avec ⌘Z / Ctrl+Z.

Conseils et erreurs courantes

  • « … » n'est pas défini ici. Le nom est mal orthographié ou son package n'est pas importé. Ajoutez private import Package::*;, ou écrivez le nom qualifié.
  • Un ; manquant. Chaque déclaration se termine par ; ou par un corps { … }. The declaration does not end. Add ; or a { … } body. (La déclaration ne se termine pas. Ajoutez ; ou un corps { … })
  • :> ou :>>. Utilisez :> pour spécialiser ou créer un sous-ensemble ; utilisez :>> pour remplacer une caractéristique héritée. Redéfinir une caractéristique qui n'est pas héritée donne « x » n'est pas hérité par « y ».
  • Les unités nécessitent des imports. 5 [kg] ne se résout que là où SI est visible.
  • Deux membres portant le même nom. « x » est déjà utilisé dans cet espace de noms. Renommez-en un ; une variante redéfinit à la place.
  • verify en dehors d'un objectif. Placez-le dans objective { verify R; } d'un cas de vérification.
  • Mots-clés utilisés comme noms. Les mots tels que part, state ou action sont réservés. Mettez-les entre apostrophes ('state') ou choisissez un autre nom.

Ce que Holarch prend en charge

Holarch prend en charge les parties suivantes de la notation textuelle SysML v2. L'éditeur les contrôle toutes, et le modèle les conserve.

DomainePris en charge
Packages et espaces de nomspackage, packages imbriqués, library package (lecture seule), doc, comment … about, notes // et //* */, alias … for …, public/private/protected, noms courts <'1.2'>, noms entre apostrophes
Importsimports d'appartenance et d'espace de noms, ::*, récursif ::**, imports filtrés [@Kind]
Définitions et usagespart, attribute, item, port, connection, interface, flow, action, state, requirement, constraint, calc, use case, analysis, verification, view, viewpoint, concern, enum, occurrence, allocation, metadata; ref, abstract, in/out/inout, end
Spécialisation:>/specializes, :/defined by, :>/subsets, :>>/redefines, conjugaison ~, disjoint, chaînes de caractéristiques a.b.c
Multiplicités[n], [n..m], [*], [0..*], ordered, nonunique, expressions comme bornes
Valeurs et unités=, :=, default, grandeurs 5 [kg], expressions d'unités [m/s^2], les natures de grandeur ISQ et les unités SI et usuelles américaines de la bibliothèque standard, contrôles des dimensions
Structureports et ports conjugués, connect, interfaces avec extrémités, extrémités de connecteur nommées avec multiplicités, bind, flow of T from … to …, message
Actionsparamètres, perform, successions (first … then …, then), fork, join, decide, merge, gardes, accept, send, assign, if, while, for, loop, start, done, terminate
Étatsentry/do/exit, transitions avec déclencheur, garde et effet, états parallel, états imbriqués, exhibit
Exigencessubject, actor, stakeholder, require constraint, assume constraint, frame concern, satisfy … by …, verify, noms courts comme identifiants, doc comme texte de l'exigence
Contraintes et calculsdéfinitions et usages de contraintes et de calculs, return, assert constraint, appels, expressions KerML avec arithmétique, comparaison, logique, if ? else et opérations sur les séquences, évaluation avec unités
Cas d'utilisation, analyse et vérificationsubject, actor, objective, include use case, cas d'analyse avec un résultat return, cas de vérification avec verify et un verdict
Vuesview, view def, expose (avec ::*, ::** et des filtres), filter, viewpoint, frame, render, les définitions de vue standard
Allocation et tracesallocate a to b, définitions d'allocation, dependency from … to …
Individusdéfinitions et usages individual, snapshot et timeslice (aussi après then), leurs valeurs et leurs successions
Variabilitédéfinitions et usages variation, membres variant et références de variante (variant x;), choix par valeur, configurations marquées @HolarchConfiguration (HolarchVariability)
Métadonnées@Name { … }, le préfixe #Name, metadata Name about …, les packages HolarchMetadata (TBD, TBR) et HolarchFrameworks de Holarch ; metadata def définies par l'utilisateur ; mots-clés définis par l'utilisateur et métadonnées sémantiques (#fault def …)

Conservé tel quel, non interprété

Holarch lit et conserve ces constructions exactement telles qu'elles sont écrites, mais ne leur donne aucun sens propre :

  • les représentations textuelles dans des langages autres que SysML et KerML (conservées sous forme de texte ; voir Représentations textuelles).

Pas encore disponible

  • Importer des fichiers KerML (.kerml).
  • Commits sur main, tags et fusions via la Systems Modeling API : les autres outils commitent dans des branches de demande de modification, qu'un approbateur applique dans Holarch (voir L'API et MCP dans les projets SysML v2).
  • Extensions du langage au-delà des mots-clés définis par l'utilisateur et des métadonnées sémantiques.

Contrôles

Holarch contrôle le texte pendant la saisie. Chaque problème est marqué dans la marge de l'éditeur et souligné ; le message indique le problème, puis la correction. Les erreurs empêchent l'application d'un membre ; les avertissements, non.

DomaineCe qui est contrôléExemple de message
SyntaxeCaractères, commentaires, chaînes, accolades, ;, noms et jetons attendusCette accolade n'a pas de partenaire. Ajoutez le { ou le } correspondant, ou supprimez celle-ci.
NomsNoms non résolus, ambigus, invalides, en double (avertissement) et privés« Batery » n'est pas défini ici. Vérifiez l'orthographe, ou importez son package.
Typage et spécialisationCycles ; typage et spécialisation par une définition du bon type ; sous-ensembles et redéfinitions de caractéristiques ; redéfinition des seules caractéristiques héritées« capacity » n'est pas hérité par « Car ». Spécialisez son type, ou créez-en un sous-ensemble avec :> à la place.
MultiplicitésBornes valides et entières ; une redéfinition pas plus large que ce qu'elle redéfinitLa multiplicité [3..1] n'est pas valide. Utilisez une borne inférieure comprise entre 0 et la borne supérieure.
Unités et valeursDimensions concordantes, unités manquantes, noms d'unités, types de nombresLes unités ne correspondent pas : kg et s. Convertissez un côté dans une unité compatible.
ExpressionsSyntaxe, types des opérandes, arguments des calculs, conditions booléennesLa condition doit être vraie ou fausse ; c'est un nombre. Écrivez une comparaison telle que x > 0.
StructureLes extrémités de connexion sont des caractéristiques, les interfaces relient des ports, directions des ports, des flux et des messages, types des items de flux, types des liaisonsCes directions de ports ne sont pas compatibles. Conjuguez un port (~) ou changez une direction.
ActionsSuccessions entre actions du même corps, nombres d'entrées et de sorties des nœuds de contrôle, gardes de décision et else, start et done, affectations, cibles de perform, valeurs parcourues par une boucle for par rapport au type de la variable de bouclethen nécessite une action antérieure. Ajoutez une action ou first … then ….
ÉtatsTransitions entre états du même corps, un seul entry/do/exit chacun, transitions initiales, régions parallèles, cibles d'exhibit, l'effet do d'une transition (send vers quelque chose qui peut recevoir, assign, accept, action ou une action nommée), la charge utile d'un déclencheur par rapport aux items de son port, un déclencheur sur une simple valeur de bibliothèque telle que Real (avertissement), les déclencheurs at qui nomment un instant« electric » a des sous-états mais aucune transition initiale, donc aucun d'eux n'est activé. Ajoutez entry; then <first state>;.
Exigences, cas et vuesMembres au bon endroit, un seul sujet, cibles de satisfy/verify/require, types de sujet, cibles d'expose et d'import, cibles de frameverify appartient à l'objectif d'un cas de vérification. Déplacez-le dans objective { … }.
Représentations textuellesLes corps SysML et KerML sont analysés et déclarent l'élément qu'ils représentent ; les langages inconnus sont signalésLa représentation de « SpeedLimit » déclare une définition de partie, et non une définition de contrainte. Faites en sorte que le corps déclare « SpeedLimit » lui-même.
Individus, instantanés et tranches temporellesindividual uniquement sur des occurrences et avec exactement une définition individuelle ; snapshot/timeslice uniquement sur des usages d'occurrence à l'intérieur d'une occurrence ; une tranche de temps à l'intérieur d'un instantané (avertissement)« parked » est individuel, mais aucune de ses définitions ne l'est. Typez-le par une définition individuelle, ou retirez individual.
VariabilitéUne variation ne possède que des variantes ; une variante se trouve dans une variation et est de son type ; un choix est une variante de son point ; abstract sur une variation est redondant (remarque) ; les points ouverts d'une configuration (remarque)« compact » n'est pas une variante de « pack ». Choisissez parmi : standardPack, largePack.
Mots-clés définis par l'utilisateur#Name nomme une définition de métadonnées ; une déclaration sans mot-clé du langage utilise des métadonnées sémantiques (avertissement) ; les métadonnées ne marquent que les types que leur annotatedElement autorise ; un type de base sémantique est une définition ou un usage, convient à l'élément qu'il marque (avertissement) et ne crée pas de cycle« safetyCritical » s'applique à PartDefinition, et non à « invert » (ActionUsage). Déplacez-le, ou retirez-le.
Valeurs des métadonnéesChaque caractéristique obligatoire d'une définition de métadonnées définie par l'utilisateur reçoit une valeur (avertissement) ; chaque valeur et valeur par défaut correspond au type de sa caractéristique (Boolean, String, nombres entiers, énumérations) ; les contraintes de la définition sont respectées par les valeurs données ; un corps de métadonnées ne redéfinit que les caractéristiques de la définition ; les définitions de métadonnées abstraites ne sont pas appliquées ; métadonnées sémantiques écrites avec about (avertissement)Les valeurs de « SafetyRating » enfreignent sa contrainte levelRange : level >= 1 and level <= 4. Modifiez les valeurs.
ÉvaluationContraintes, exigences et objectifs qui ne sont pas respectés pour les valeurs actuelles« sedanMass » n'est pas respectée par « sedan » : … est faux (…). Modifiez les valeurs de conception ou l'exigence.

La bibliothèque standard

La page Bibliothèque standard liste les packages et les définitions que tout projet SysML v2 peut utiliser : valeurs et unités, grandeurs, parties, ports, actions, états, exigences, analyse et plus encore. Elle est en lecture seule.

  • Ouvrez-la depuis Paramètres → Bibliothèque standard dans les outils du rail. Les projets LML ne l'ont pas.
  • Dossiers. Le côté gauche liste les fichiers de la bibliothèque par dossier : Kernel Libraries, Systems Library, Domain Libraries (Analysis, Cause and Effect, Geometry, Metadata, Quantities and Units, Requirement Derivation) et Holarch (le package HolarchMetadata avec TBD et TBR, HolarchVariability avec HolarchConfiguration, et HolarchRequirements avec Objective).
  • Un fichier. Sélectionnez un fichier pour voir ses packages, chacun avec sa documentation et un tableau de ses définitions : Nom, Type et Documentation.
  • Rechercher. Saisissez du texte dans Rechercher un package ou une définition… pour chercher dans les noms et la documentation de tous les fichiers. Les résultats indiquent le fichier ; cliquez dessus pour ouvrir ce fichier. Appuyez sur Esc pour effacer.
  • Copier le nom copie le nom qualifié d'un élément, tel que ISQ::MassValue, pour l'utiliser dans l'éditeur.
  • Afficher le texte affiche le fichier de bibliothèque tel qu'il est écrit ; Afficher les définitions revient aux tableaux.

La bibliothèque est la bibliothèque de la version publiée de SysML v2, avec une correction : une tonne (alias 'metric ton') se convertit en 1000 kg ; le fichier publié indique 0,001 kg. Votre modèle y fait référence par son nom ; elle n'est pas copiée dans le projet et ne fait pas partie d'un export .sysml.

Limites

  • Un document texte de plus de 8 Mo n'est pas contrôlé : This text is larger than 8 MB and is not checked. Split it into several packages. (Ce texte dépasse 8 Mo et n'est pas contrôlé. Divisez-le en plusieurs packages)
  • Une ligne de plus de 64 Ko n'est pas contrôlée.
  • Une imbrication de plus de 256 niveaux n'est pas contrôlée.
  • La bibliothèque standard ne peut pas être modifiée.

SysML® et OMG® sont des marques déposées d'Object Management Group, Inc. aux États-Unis et dans d'autres pays.