Guide · SysML v2
Outils SysML v2 : ce qu'il faut vérifier avant d'en choisir un
Écouter ce guide (audio en anglais) 16 min
Un guide d'évaluation des outils SysML v2 : ce qu'il faut vérifier chez tout candidat, comment distinguer une prise en charge réelle d'une diapositive, un tableau de contrôle pour les noter, et un petit modèle de test à charger dans chacun.
Sur cette page
- Pourquoi les outils SysML v2 ont besoin de leur propre évaluation
- Ce qu'il faut vérifier
- Couverture du langage, et documentation des lacunes
- Notation textuelle : édition et contrôle
- Vues graphiques, et synchronisation texte-diagramme
- Bibliothèque standard
- La Systems Modeling API
- Échange JSON et aller-retour
- Migration depuis SysML v1
- Collaboration et gestion de versions
- Exigences et vérification sur le modèle
- Analyse et évaluation avec unités
- Déploiement : cloud ou auto-hébergé
- Licences et coût
- Formation
- Une liste de contrôle d'évaluation
- Un modèle de test à charger dans tout candidat
- Mener l'évaluation
- Les réponses de Holarch à la liste de contrôle
- L'essayer dans Holarch
- Pour aller plus loin
Pourquoi les outils SysML v2 ont besoin de leur propre évaluation
SysML v2 est un nouveau langage, pas une révision de SysML v1 (en quoi SysML v1 et v2 diffèrent les compare en détail). Il possède une notation textuelle en plus d'une notation graphique, une base sémantique formelle dans KerML, une bibliothèque standard de grandeurs, d'unités et de types de vues, et une API standard pour lire et écrire des modèles. Un outil peut revendiquer la prise en charge de SysML v2 tout en n'en couvrant qu'une partie, et les parties qu'il laisse de côté peuvent être celles dont dépend votre programme.
La spécification est vaste, et chaque outil la met en œuvre par étapes. C'est normal. Ce qui compte dans une évaluation, c'est de savoir quelles étapes un outil a franchies, lesquelles il n'a pas franchies, et si l'éditeur vous le dit clairement. Les contrôles ci-dessous s'appliquent à tout outil SysML v2, quels que soient son prix ou son déploiement, et le modèle de test vous donne la même entrée pour chaque candidat.
Pour trouver des candidats, partez de la liste des outils SysML v2 tenue par l'OMG et du résumé des capacités des outils SysML v2 que l'INCOSE et l'OMG ont publié pour accompagner le passage depuis SysML v1. Ce sont deux points de départ : lisez-les pour les noms, puis testez vous-même chaque outil.
Ce qu'il faut vérifier
Couverture du langage, et documentation des lacunes
Demandez une déclaration de couverture : chaque domaine du langage (packages, définitions et usages, spécialisation et redéfinition, multiplicités, valeurs et unités, contraintes, structure, actions, états, exigences, cas d'utilisation, cas d'analyse et de vérification, vues, métadonnées, variabilité, individus et tranches temporelles) avec un niveau pour chacun. Des niveaux utiles distinguent quatre cas :
- l'outil analyse, contrôle et utilise la construction ;
- il le fait avec des limites nommées ;
- il conserve la construction exactement telle qu'écrite mais ne lui donne aucun sens (elle survit à un aller-retour, mais rien ne la contrôle ni ne la calcule) ;
- il ne l'accepte pas.
Un éditeur qui publie ses lacunes connues permet de mieux planifier qu'un éditeur qui ne liste que des fonctionnalités. Considérez « prend en charge SysML v2 » sans tableau de couverture comme une inconnue, et testez les constructions qu'utilisent vos modèles.
Notation textuelle : édition et contrôle
La notation textuelle est là où SysML v2 diffère le plus de v1, et là où les outils diffèrent le plus. Vérifiez :
- Édition : coloration syntaxique, complétion des noms et des mots-clés, aller à la définition, renommage dans tout le modèle, rechercher et remplacer.
- Contrôle pendant la saisie : les erreurs de syntaxe sont le minimum. Un vérificateur utile résout aussi chaque nom à travers les imports, signale les noms en double et ambigus, contrôle les redéfinitions par rapport à ce qui est hérité, compare les dimensions des unités, et compare les sens des ports et des flux à travers les connexions.
- Le texte est le modèle : après une modification, chaque autre vue voit-elle le changement, ou le texte est-il un fichier que l'outil importe de temps en temps ?
- Du texte que l'outil n'a pas écrit : chargez du texte écrit à la main ou par un autre outil. Les commentaires, la documentation et la mise en forme du texte doivent survivre.
Vues graphiques, et synchronisation texte-diagramme
En SysML v2, une vue est un élément du modèle : elle énonce ce qu'elle expose et filtre, et l'outil la restitue. La bibliothèque standard définit les vues General, Interconnection, Action Flow, State Transition, Sequence et Grid. Vérifiez lesquelles l'outil dessine, dans lesquelles il permet de modifier, et comment il gère la disposition, que la spécification laisse à l'outil.
Le test clé est la synchronisation dans les deux sens. Renommez une part dans le texte et regardez chaque diagramme qui la montre. Ajoutez une connexion dans un diagramme et lisez le texte produit. Puis modifiez les deux côtés en même temps, si deux personnes le peuvent, et voyez ce que l'outil fait du conflit.
Bibliothèque standard
Une grande partie du sens de SysML v2 réside dans sa bibliothèque standard : valeurs scalaires, Système international de grandeurs, unités SI et usuelles américaines, définitions de vues standard et bibliothèques du noyau KerML. Un outil doit fournir la bibliothèque, résoudre les noms par rapport à elle et évaluer avec elle. Vérifiez que les natures de grandeurs ISQ et les unités SI se résolvent, que la bibliothèque ne peut pas être modifiée par accident, et quelle version de la bibliothèque l'outil utilise.
La Systems Modeling API
La Systems Modeling API est l'interface REST standard d'un référentiel de modèles : projets, branches, commits et éléments. Elle permet aux outils d'échanger des modèles sans fichiers, et à vos propres scripts de lire des modèles. Un outil peut y jouer deux rôles, chacun pouvant être en lecture seule :
- Client : l'outil lit depuis un autre référentiel qui propose l'API et y écrit.
- Serveur : l'outil propose l'API pour que d'autres outils lisent, et éventuellement écrivent, ses modèles.
Demandez quel rôle, quelles routes, et si les écritures, requêtes, diffs et anciens commits sont proposés. Un serveur en lecture seule reste utile pour le reporting et pour alimenter des outils d'analyse ; il ne suffit pas quand un autre outil doit modifier le modèle.
Échange JSON et aller-retour
Outre le texte, les modèles circulent entre outils en JSON SysML v2 : le format d'élément de l'API, avec un identifiant pour chaque élément. Les identifiants comptent : le texte n'en porte aucun, donc un outil qui réimporte du texte ne peut faire correspondre les éléments que par leur nom, alors que le JSON conserve l'identité à travers un échange. Testez un aller-retour : exportez depuis l'outil A, importez dans l'outil B, exportez de nouveau et importez dans A. Comparez ensuite le nombre d'éléments, les noms, les valeurs avec unités et les relations, et lisez comment chaque outil signale ce qu'il a abandonné. Les types d'éléments qu'un outil ne prend pas en charge sont l'endroit où les allers-retours perdent des données.
Migration depuis SysML v1
Il n'existe pas de traduction automatique sans perte de v1 vers v2 : les langages diffèrent par leur structure, et les diagrammes v1 portent une disposition et des stéréotypes qui n'ont pas d'équivalent v2 unique. Demandez comment l'outil importe les modèles v1 (généralement du XMI avec le profil SysML 1.x), en quoi il transpose les blocs, parts, ports, activités, machines à états et exigences, et s'il produit un rapport de ce qui n'a pas été converti. Essayez-le sur l'un de vos propres modèles v1, pas sur l'exemple de l'éditeur.
Collaboration et gestion de versions
Les modèles de systèmes sont un travail d'équipe. Vérifiez si plusieurs personnes peuvent modifier en même temps et comment les conflits sont affichés et résolus, quels rôles existent (modification, revue, lecture), comment fonctionnent l'historique et les références, et si vous pouvez comparer deux versions élément par élément et sous forme de texte. Si votre organisation conserve ses modèles dans un dépôt, vérifiez les branches, les fusions et le rapport entre l'historique des versions propre à l'outil et les commits du dépôt.
Exigences et vérification sur le modèle
SysML v2 fait d'une exigence une contrainte sur un sujet, avec des relations satisfy et verify vers la conception et les cas de vérification. Vérifiez que l'outil garde ensemble le texte de l'exigence et la contrainte, évalue la contrainte par rapport aux valeurs du modèle et construit une matrice de vérification à partir des liens verify. Vérifiez aussi ce que l'outil conserve en dehors du langage : statut des exigences, approbations, résultats de test et liens suspects après une modification. Ils ne font pas partie du texte SysML v2 ; demandez donc où ils sont stockés et s'ils accompagnent un export.
Analyse et évaluation avec unités
Chaque valeur d'un modèle SysML v2 peut porter une unité, et les expressions les combinent. Vérifiez que l'outil évalue les expressions avec unités (une masse totale à partir des masses de trois parts, en kilogrammes), signale une erreur de dimension comme une erreur, et évalue les contraintes d'exigences par rapport au résultat. Vérifiez ensuite les fonctionnalités d'analyse plus larges dont vous avez besoin : résolution paramétrique, budgets et consolidations, études de compromis, simulation de flux d'actions ou de machines à états. Demandez ce qui est évalué à partir du modèle et ce qui nécessite des données supplémentaires propres à l'outil.
Déploiement : cloud ou auto-hébergé
Vérifiez où vit le modèle et qui exploite l'outil : un service hébergé, une installation de bureau ou un serveur dans votre propre environnement. Pour les données contrôlées ou soumises à des restrictions d'exportation, renseignez-vous sur l'auto-hébergement, la localisation des données, les options de connexion et la façon dont les fonctionnalités d'IA, s'il y en a, sont configurées ou désactivées.
Licences et coût
Comparez le coût total pour votre équipe, pas le prix catalogue par poste : lecteurs et relecteurs, usage académique ou d'évaluation, coût d'une option API ou serveur, et ce que deviennent vos modèles si vous cessez de payer. Vérifiez si un export dans les formats standard est disponible dans chaque offre, pour que vos modèles restent les vôtres.
Formation
SysML v2 est nouveau pour la plupart des ingénieurs, y compris ceux qui maîtrisent v1. Recherchez une documentation de référence qui couvre la notation telle que l'outil la prend en charge, des exemples détaillés, un modèle de démonstration à explorer et des supports guidés pour les écrans propres à l'outil. La formation au langage et la formation à l'outil sont des besoins différents ; vérifiez que les deux sont couverts.
Une liste de contrôle d'évaluation
Notez chaque candidat avec les mêmes questions et la même entrée. « Montré » signifie que vous l'avez vu fonctionner sur le modèle de test ou sur votre propre modèle, pas sur une diapositive.
| Domaine | Question à poser | Comment le tester |
|---|---|---|
| Couverture du langage | Existe-t-il un tableau de couverture publié avec les lacunes connues ? | Y trouver les constructions qu'utilisent vos modèles ; charger le modèle de test |
| Notation textuelle | L'éditeur contrôle-t-il les noms, les redéfinitions, les unités et les sens pendant la saisie ? | Charger les deux sondes ; chacune doit signaler un problème |
| Vues graphiques | Quelles vues standard sont dessinées et modifiables ? | Ouvrir une vue d'interconnexion et une vue des transitions d'état du modèle de test |
| Synchronisation texte-diagramme | Une modification d'un côté apparaît-elle immédiatement de l'autre ? | Renommer controller dans le texte ; ajouter une connexion dans un diagramme et lire le texte |
| Bibliothèque standard | Les grandeurs ISQ, les unités SI et les vues standard se résolvent-elles ? | Le modèle de test importe ISQ, SI et StandardViewDefinitions |
| Systems Modeling API | Client, serveur, ou les deux ? Lecture seule, ou lecture et écriture ? | Lire les éléments du modèle de test depuis un autre outil ou avec un script |
| Aller-retour JSON | Les identifiants des éléments sont-ils conservés ? Qu'est-ce qui est abandonné, et est-ce signalé ? | Exporter, importer dans un second outil, exporter de nouveau, comparer |
| Migration v1 | Existe-t-il une voie d'import depuis SysML v1, avec un rapport ? | Convertir l'un de vos propres modèles v1 |
| Collaboration | Modification simultanée, rôles, références, comparaison ? | Deux personnes modifient le même package ; comparer avec une référence |
| Exigences et vérification | Les contraintes sont-elles évaluées et une matrice de vérification construite ? | Abaisser la limite de masse à 20 kg et voir l'exigence échouer |
| Analyse avec unités | Les valeurs sont-elles évaluées avec leurs unités ? Que calcule-t-il d'autre ? | Vérifier que totalMass s'évalue à 23 kg |
| Déploiement | Hébergé, bureau, auto-hébergé ? | Demander les options par écrit, avec la localisation des données |
| Licences et coût | Coût total pour les auteurs, relecteurs et lecteurs ; export dans chaque offre ? | Chiffrer votre équipe, relecteurs compris |
| Formation | Référence du langage, exemples, guides de l'outil ? | Faire modéliser le système de test par un nouvel utilisateur à partir de la seule documentation |
Un modèle de test à charger dans tout candidat
Ce modèle est assez petit pour être saisi et touche pourtant l'essentiel de ce dont une évaluation a besoin : imports depuis la bibliothèque standard, définitions et usages de part avec valeurs redéfinies et unités, ports conjugués, connexions et une liaison, une machine à états, une action avec des successions, deux exigences avec contraintes, un satisfy, un cas de vérification et deux vues. Enregistrez-le sous pump-station.sysml et chargez-le dans chaque outil.
Le système est une pompe à eau solaire : un panneau alimente un contrôleur, et le contrôleur commande la pompe. L'unité ne doit pas peser plus de 25 kg, et la puissance crête du panneau doit dépasser la puissance nominale de la pompe d'au moins 20 %. Si la notation est nouvelle pour vous, le tutoriel SysML v2 présente chaque construction utilisée par ce modèle.
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;
}
}
Ce qu'un outil qui prend en charge ces constructions doit montrer :
- Aucune erreur et aucun avertissement. Un outil qui signale des problèmes ici soit ne dispose pas d'une construction, soit lit la bibliothèque standard différemment ; demandez lequel des deux.
totalMasss'évalue à 23 kg : 12 kg + 2 kg + 9 kg.- Les deux exigences sont tenues : 23 kg est dans la limite de 25 kg, et 400 W est supérieur à 1,2 × 300 W = 360 W.
unitConnectionsdessine le panneau, le contrôleur et la pompe avec leurs ports, les deux connexions, et la sortie liée à la frontière de l'unité.pumpStatesdessine deux états avec une transition initiale et deux transitions déclenchées.- Une matrice de vérification liste
PS-1vérifiée parVC-1, etPS-2sans cas de vérification.
Deux sondes pour le vérificateur
Un vérificateur montre sa valeur sur les erreurs. Chargez chaque sonde séparément ; chacune contient exactement un problème.
La première donne à une puissance une valeur en kilogrammes. Un outil qui contrôle les dimensions signale une erreur sur la valeur :
package UnitProbe {
private import ISQ::*;
private import SI::*;
part def Pump {
attribute ratedPower : PowerValue;
}
part pump : Pump {
attribute redefines ratedPower = 300 [kg];
}
}
La seconde s'analyse et se résout sans problème, mais son exigence n'est pas tenue : l'unité pèse 11 kg pour une limite de 10 kg. Un outil qui évalue les contraintes d'exigences le signale ; un outil qui se contente d'analyser l'accepte sans rien dire.
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;
}
Les deux sondes ont été contrôlées avec un moteur de langage, comme le modèle de test : le modèle ne produit aucun problème, et chaque sonde produit exactement le problème décrit.
Mener l'évaluation
- Notez d'abord vos besoins. Les constructions qu'utilisent vos modèles, les vues que lisent vos relecteurs, les outils qui doivent échanger des modèles, et l'endroit où les données peuvent résider. Pondérez les lignes de la liste de contrôle en conséquence.
- Lisez la déclaration de couverture et les lacunes connues de chaque éditeur. Marquez chaque ligne de la liste de contrôle comme revendiquée, non revendiquée ou non indiquée.
- Chargez le modèle de test et les sondes dans chaque candidat. Consignez ce que chaque outil signale, mot pour mot.
- Chargez l'un de vos propres modèles. Un vrai modèle trouve des problèmes qu'aucun exemple ne trouve : taille, nommage, constructions inhabituelles.
- Faites un aller-retour avec l'outil avec lequel vous échangez le plus.
- Faites construire le modèle de test par un nouvel utilisateur à partir de la seule documentation de l'outil, et chronométrez-le.
Conservez les preuves (captures d'écran, fichiers exportés, messages donnés par chaque outil) avec les notes. Un enregistrement de décision qui montre ce qui a été testé vaut plus pour un comité de revue qu'une matrice de fonctionnalités copiée des documents des éditeurs.
Les réponses de Holarch à la liste de contrôle
Holarch est l'outil utilisé pour les captures d'écran de cette page ; voici donc ses propres réponses, chacune avec la page qui l'étaye. « Partiel » et « Pas encore » signifient ce qu'ils disent.
| Domaine | Niveau | Holarch aujourd'hui |
|---|---|---|
| Couverture du langage | Partiel | Un tableau publié de chaque domaine avec son niveau, ses limites et ses lacunes connues. La variabilité, les individus et tranches temporelles, les mots-clés définis par l'utilisateur et les métadonnées sémantiques sont contrôlés et évalués ; les fichiers .kerml ne sont pas encore importés ; les représentations textuelles en SysML et KerML sont contrôlées, celles en d'autres langages conservées sous forme de texte. Couverture du langage SysML v2 |
| Notation textuelle | Pris en charge | Un Éditeur qui contrôle pendant la saisie (syntaxe, noms, typage, multiplicités, unités, sens, évaluation), avec complétion, aller à la définition, renommage et rechercher-remplacer. L'Éditeur, Contrôles |
| Vues graphiques | Partiel | Vues générale, d'interconnexion, de flux d'action, des transitions d'état, de séquence et grille, toutes modifiables. Les vues de séquence dessinent les messages entre lignes de vie et les fragments combinés (alt, opt, loop et par). Vues SysML v2 |
| Synchronisation texte-diagramme | Pris en charge | Un seul modèle derrière le texte et chaque vue ; une modification d'un côté apparaît de l'autre. Le texte et les vues restent synchronisés |
| Bibliothèque standard | Pris en charge | Chargée et en lecture seule, avec les unités ISQ, SI et usuelles américaines et les définitions de vues standard. La bibliothèque standard |
| Systems Modeling API | Partiel | En tant que client : lire depuis une branche d'un référentiel qui propose l'API et y écrire. En tant que serveur : d'autres outils lisent le modèle actuel et font des commits dans des branches de demande de modification, qu'un approbateur applique dans Holarch. Pull et push, Systems Modeling API |
| Aller-retour JSON | Partiel | Import et export JSON SysML v2 avec conservation des identifiants des éléments. Les types d'éléments que Holarch n'interprète pas sont conservés tels qu'importés et réécrits inchangés à l'export. Échanger des modèles SysML v2 |
| Migration v1 | Partiel | Import direct d'un modèle SysML 1.x (.mdzip Cameo ou MagicDraw, ou XMI de Cameo, Enterprise Architect, Rhapsody ou Papyrus) dans un projet SysML v2, converti en texte SysML v2 et contrôlé, avec un rapport de ce qui a été converti, approché ou laissé de côté et pourquoi. Les diagrammes et leur disposition ne sont pas convertis. Importer des modèles SysML v1 |
| Collaboration | Pris en charge | Édition en direct avec fusion membre par membre dans l'Éditeur, rôles, références qui contiennent le modèle, et comparaison par élément et par texte de package. Collaboration, Références |
| Exigences et vérification | Pris en charge | Contraintes d'exigences évaluées par rapport au modèle, RVTM et Centre de test construits à partir des liens verify, approbations, TBD/TBR et liens à revoir. Exigences et vérification |
| Analyse avec unités | Partiel | Évaluation avec unités, vues paramétriques qui résolvent une inconnue par contrainte, budgets, études de compromis, et simulation de flux d'actions et de machines à états. Un cas d'analyse n'est évalué que lorsque chaque entrée a une valeur. Évaluation, unités et analyse |
| Déploiement | Pris en charge | Une application web hébergée, et des déploiements auto-hébergés dans votre propre environnement sur demande. Sécurité, Contact |
| Licences et coût | Pris en charge | Une offre Free pour les étudiants, les enseignants, les projets personnels et l'évaluation individuelle ; les entreprises peuvent essayer gratuitement l'offre Individual pendant 1 mois ; des offres payantes pour l'usage commercial ; relecteurs et lecteurs gratuits dans chaque offre. Tarifs |
| Formation | Partiel | Une référence dans la documentation pour chaque page SysML v2, un tutoriel pas à pas, la démo Hybrid Car, neuf tutoriels SysML v2 guidés dans l'application et une série de tutoriels vidéo SysML v2 qui construit le modèle Hybrid Car. Les parcours de formation vidéo couvrent les projets LML. Démarrer, Tutoriels SysML v2, Tutoriel SysML v2 |
L'essayer dans Holarch
- Enregistrez le modèle de test sous
pump-station.sysml. - Ouvrez Modèle → Importer et exporter, choisissez Dans un nouveau projet SysML v2 et déposez le fichier. Voir importer des fichiers dans un nouveau projet.
- Ouvrez Modèle → Éditeur. La ligne d'état indique « Aucun problème », et chaque package est un document.
- Ouvrez la liste Diagrammes et cliquez sur
unitConnectionsoupumpStates. - Ouvrez Vérification → RVTM pour voir les exigences avec le cas qui les vérifie.
unitConnections : ports conjugués, deux connexions et une liaison.verify du modèle.Pour aller plus loin
- Tutoriel SysML v2 : construire un modèle plus grand pas à pas dans la notation textuelle.
- SysML v1 et v2 : ce qui change entre les deux langages et ce qu'implique une migration.
- Couverture du langage SysML v2 : le tableau de couverture complet de Holarch et ses lacunes connues.
- Les projets SysML v2 dans Holarch : texte, vues et pages d'ingénierie sur un seul modèle.