Holarch

SysML v2

Notación textual de SysML v2

El lenguaje SysML v2 tal como lo admite Holarch, con ejemplos de la demostración Hybrid Car, las comprobaciones que ejecuta y la Biblioteca estándar de solo lectura.

Cómo usarlo →

En esta página
  1. Resumen
  2. Conceptos
    1. Elementos, propietarios y nombres cualificados
    2. Paquetes
    3. Importaciones y visibilidad
    4. Definiciones y usos
    5. Tipado, especialización y redefinición
    6. Multiplicidades
    7. Valores y unidades
    8. Estructura: puertos, conexiones, interfaces, enlaces y flujos
    9. Comportamiento: acciones
    10. Comportamiento: estados
    11. Requisitos, restricciones y verificación
    12. Casos de uso
    13. Vistas
    14. Comentarios, documentación y metadatos
    15. Individuos, instantáneas y segmentos temporales
    16. Variaciones, variantes y configuraciones
    17. Representaciones textuales
  3. Cómo usarlo
    1. Modelar una estructura
    2. Dar valores con unidades
    3. Describir el comportamiento
    4. Escribir un requisito y trazarlo
    5. Marcar un valor como TBD o TBR
    6. Buscar un nombre de la biblioteca
  4. Ejemplo práctico: leer el requisito del sedán
  5. Consejos y errores comunes
  6. Qué admite Holarch
    1. Se conserva tal como está escrito, sin interpretarlo
    2. Aún no disponible
  7. Comprobaciones
  8. La Biblioteca estándar
  9. Límites
  10. Páginas relacionadas

Resumen

SysML v2 describe un sistema como un árbol de elementos con nombre, escrito como texto. Holarch admite la notación textual de SysML v2, basada en la especificación OMG SysML v2. El texto se escribe en el Editor, y Holarch muestra los mismos elementos en el Navegador, las vistas, las tablas y las páginas del ciclo de vida.

Esta página enseña la notación con ejemplos de la demostración Hybrid Car (SysML v2). Después enumera lo que admite Holarch, las comprobaciones que ejecuta sobre su texto y la Biblioteca estándar.

Conceptos

Elementos, propietarios y nombres cualificados

Todo elemento tiene un propietario, excepto los paquetes de nivel superior. El nombre cualificado de un elemento es la cadena de los nombres de sus propietarios, unidos por ::. En la demostración, la batería de la definición del tren motriz es Vehicles::Powertrain::battery.

Un nombre con espacios u otros caracteres especiales va entre comillas simples: 'Fuel Tank'. Un nombre corto entre corchetes angulares da a un elemento un segundo identificador, corto: requirement def <'VR-1'> CurbMass. Holarch usa el nombre corto de un requisito como su número.

Paquetes

Un paquete agrupa elementos, como una carpeta. Los paquetes se pueden anidar. Cada paquete de nivel superior es un documento en el Editor.

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

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

Importaciones y visibilidad

Una importación hace visibles los miembros de otro paquete por sus nombres cortos.

  • import ISQ::*; importa los miembros de ISQ.
  • import VehicleRequirements::**; importa también los miembros de los elementos anidados (recursiva).
  • import Vehicles::Car; importa un solo elemento.
  • import Vehicles::*[@SysML::PartDefinition]; importa solo los miembros de un tipo (una importación filtrada).

private, protected y public establecen quién más ve un miembro o una importación. La demostración escribe private import para que las importaciones no pasen a los paquetes que a su vez la importan.

Sin una importación, escriba el nombre cualificado: ISQ::MassValue se resuelve en cualquier lugar, MassValue solo donde se importa ISQ.

Un alias da a un elemento un segundo nombre: alias Hybrid for Car;.

Definiciones y usos

Una definición describe un tipo de cosa. Un uso es un empleo de una definición dentro de otro elemento. La mayoría de las palabras clave existen en ambas formas:

DefiniciónUsoQué es
part def Battery;part battery : Battery;Un sistema, subsistema o componente
attribute def TirePressure;attribute mass : MassValue = 45 [kg];Un valor, a menudo con unidades
item def Fuel;item fuel : Fuel;Algo que fluye o se manipula
port def FuelPort { … }port fuelOut : FuelPort;Un punto de conexión en una parte
connection def … / interface def FuelLine { … }interface fuel : FuelLine connect …;Un vínculo entre partes o puertos
action def ProduceTorque { … }action produce : ProduceTorque;Comportamiento: un paso que toma entradas y produce salidas
state def PowertrainStates { … }state off;Comportamiento: un estado y sus transiciones
constraint def MassLimit { … }constraint …;Una condición booleana sobre valores
calc def PowerToWeight { … }calc …;Un cálculo con un valor return
requirement def <'VR-1'> CurbMass { … }requirement <'VR-1.1'> sedanMass : CurbMass;Un requisito
use case def DriveToWork { … }use case commute : DriveToWork;Un caso de uso
analysis def PowerToWeightAnalysis { … }analysis sedanPowerToWeight : …;Un caso de análisis
verification def CurbMassTest { … }verification sedanWeighing : CurbMassTest;Un caso de verificación
view def RequirementsView { … }view driveCycleFlow : ActionFlowView { … }Una vista del modelo
enum def DriveMode { … }attribute mode : DriveMode;Un conjunto fijo de valores

Los miembros anidados en una definición pertenecen a todos sus usos. part frontAxle : Axle; tiene el differential, la leftWheel y la rightWheel de Axle sin repetirlos.

Tipado, especialización y redefinición

Cuatro operadores relacionan definiciones y usos. Cada uno tiene también una forma de palabra clave.

OperadorPalabra claveSignificadoEjemplo
:defined byTipa un uso mediante una definiciónpart engine : Engine;
:> en una definiciónspecializesLa definición es un tipo de la otra y hereda sus miembrospart def FuelTank :> Component
:> en un usosubsetsEl uso es un subconjunto de otro usopart spareWheel :> wheels;
:>>redefinesSustituye un uso heredado, por ejemplo para darle un valorattribute redefines mass = 18 [kg];
~Conjuga un puerto: sus características in y out se intercambianport fuelIn : ~FuelPort;

La redefinición es la forma en que una variante o una parte configurada cambia lo que hereda. En la demostración, SportCar elimina la rueda de repuesto mediante redefinición:

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

abstract marca una definición que no tiene instancias directas (abstract part def Component). ref marca una referencia que no es propiedad del elemento. in, out e inout establecen la dirección de una característica o un parámetro. end marca los extremos de una definición de conexión o de interfaz.

Multiplicidades

Una multiplicidad entre corchetes indica cuántos hay.

  • [2]: exactamente dos. part runabout : CityCar [2];
  • [0..1]: opcional. part spare : Wheel [0..1];
  • [1..*] y [*]: uno o más, cualquier número.
  • [0]: ninguno; se usa para quitar una parte heredada.
  • Los límites pueden ser expresiones. ordered y nonunique van después de los corchetes.

Valores y unidades

= enlaza un valor. := da un valor inicial que puede cambiar. default da un valor predeterminado que una redefinición puede sustituir.

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

Una magnitud es un número con una unidad entre corchetes. Las unidades se combinan con *, / y ^ ([m/s^2]). Los tipos de magnitud como MassValue proceden de ISQ, y las unidades como kg, de SI (o USCustomaryUnits). Holarch comprueba las dimensiones: asignar 5 [s] a un MassValue es un error.

Las expresiones usan aritmética, comparación (<=, ==), operadores lógicos (and, or, not, implies), la condicional if c ? a else b, cadenas de características (car.powertrain.battery.capacity), llamadas a cálculos (PowerToWeight(power, mass)) y operaciones de secuencia como ->sum, ->size, ->select y ->collect. Holarch las evalúa con unidades para los valores, las restricciones, las vistas y las páginas de análisis.

Estructura: puertos, conexiones, interfaces, enlaces y flujos

Las partes se conectan a través de sus puertos.

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; une dos partes o puertos.
  • Una interfaz es una conexión tipada entre puertos. Su definición nombra sus extremos: interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  • Cada extremo de una conexión o interfaz puede tener un nombre y una multiplicidad: interface motorShaft : Shaft connect [1] driver ::> motor.output to [1] driven ::> transmission.motorIn;. Un extremo con nombre es una característica de la conexión, de modo que motorShaft.driver se refiere a él.
  • bind a = b; indica que dos características son la misma (un conector de enlace).
  • flow of Fuel from supply.fuel to produce.fuel; lleva un item de una característica a otra. message envía un item entre partes como un evento.

Comportamiento: acciones

Una definición de acción contiene sus pasos (usos de acción), sus parámetros y el orden de los pasos.

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;
}
  • Las sucesiones ordenan los pasos: first a then b;, o then b; justo después de a. start y done son el principio y el final.
  • Nodos de control: fork y join para caminos paralelos; decide y merge para alternativas. Una sucesión con guarda después de una decisión se escribe if speed > 30 then cruise;, y else brake; es la rama predeterminada.
  • Terminar: terminate; termina de inmediato la acción que lo contiene, junto con los pasos que aún se estén ejecutando; then terminate; lo coloca después del paso anterior. terminate x; termina la ocurrencia x.
  • Otras acciones: accept espera una señal, send envía una, assign x := expr; cambia un valor, if ejecuta un bloque o lo omite, y while … { … } until …; y for v in seq { … } repiten un bloque.
  • Asignación del comportamiento: una parte realiza (perform) una acción (perform action trip : DriveCycle;, perform trip.supply;), y allocate a to b; asigna un elemento a otro.

Comportamiento: estados

Una definición de estado contiene los estados y las transiciones entre ellos.

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; establece el estado inicial.
  • Las transiciones tienen un disparador (accept StartRequest), una guarda opcional (if charge > 20) y un efecto opcional (do …). La forma corta va después del estado de origen; la forma larga es transition name first a … then b;.
  • En el modelo, el disparador y el efecto de una transición son elementos propios: una acción de aceptación y una acción (send, assign, perform, terminate o una acción con nombre). El Navegador los muestra como disparador y efecto bajo la transición. Son el accepter y el effect propios de la transición, de modo que otras partes del modelo pueden nombrarlos: chargerStates.plugIn.effect.sentMessage es el mensaje que envía el efecto, tal como lo enlaza un modelo de secuencia.
  • Un disparador a través de un puerto debe aceptar algo que el puerto transporta: en el ChargeManager de la demostración, accept connectCharger : ChargerConnected via chargePort coincide con el in connected : ChargerConnected del puerto. El efecto send new ChargeRequest() to controller envía a una parte; un valor como un atributo no puede recibir un mensaje.
  • Las acciones entry, do y exit se ejecutan al entrar en el estado, mientras se está en él y al salir de él. Los estados parallel tienen regiones que están activas todas a la vez.
  • Una parte exhibe (exhibit) un estado: exhibit state powertrainStates : PowertrainStates;.

Requisitos, restricciones y verificación

Un requisito contiene su enunciado en doc, el elemento al que se aplica como subject y una condición comprobable como 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 establece una condición que el requisito supone. Cuando no se cumple, ese requisito y los requisitos anidados en él cuentan como cumplidos; el requisito que lo rodea y los demás requisitos anidados se siguen comprobando. actor, stakeholder y frame concern nombran para quién y para qué es el requisito.
  • satisfy R by part; indica que una parte cumple un requisito.
  • Un caso de verificación verifica requisitos en su objetivo: objective { verify carSpec.sedanMass; }. Puede devolver return verdict : Boolean = …;.
  • Un caso de análisis tiene un sujeto, un objetivo y un resultado return que Holarch evalúa cuando todas las entradas tienen valor. Los atributos del caso sin valor se resuelven a partir de las ecuaciones == de su objetivo (Casos de análisis con incógnitas).
  • connection : Derivation connect original to derived; registra un requisito derivado. #refinement dependency x to R; registra un refinamiento.
  • dependency from a to b; registra una traza general.

Casos de uso

use case def DriveToWork { subject car : Car; actor driver : Driver; objective { … } include use case startCar : StartCar; }. Un uso de caso de uso toma el sujeto y los actores de su definición.

Vistas

Una vista muestra parte del modelo. Está tipada por una definición de vista estándar y expone (expose) lo que muestra:

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

filter restringe los elementos (filter @SysML::RequirementUsage;). render elige una representación. Un viewpoint enmarca las inquietudes que una vista debe abordar. Vistas de SysML v2 explica cada tipo de vista.

Comentarios, documentación y metadatos

  • doc /* text */ documenta a su propietario. Forma parte del modelo; para un requisito es el texto del requisito.
  • comment about x /* text */ es una nota en el modelo sobre otro elemento.
  • // text y //* text */ son notas solo en el texto. Holarch las conserva en el texto, pero no son elementos del modelo.
  • Los metadatos anotan un elemento: @TBD { owner = "Powertrain lead"; } en un cuerpo, #TBR attribute limit … como prefijo, o metadata Capability about Vehicles::Car; desde fuera.
  • Palabras clave definidas por el usuario: cualquier definición de metadatos funciona como palabra clave: #safetyCritical part controller : Controller; marca el controlador con los metadatos SafetyCritical (nombre corto <safetyCritical>). Una definición de metadatos puede limitar lo que marca: :>> annotatedElement : SysML::PartDefinition; solo permite definiciones de part.
  • Metadatos semánticos: una definición de metadatos que especializa SemanticMetadata establece un tipo base, :>> baseType = faults meta SysML::Usage;. Todo elemento que marca especializa entonces la base: un uso es un subconjunto de un uso base, y una definición especializa una definición base o las definiciones de un uso base. Así, #fault def BatteryOverheat; y #fault overheat : BatteryOverheat; son fallos y tienen las características de Fault. Con metadatos semánticos se puede omitir la palabra clave del lenguaje, como en estas dos líneas; el Navegador los muestra con su palabra clave (#fault def). Escrito desde fuera, metadata Fault about x; no convierte x en un fallo: la comprobación avisa y sugiere marcar el propio x con #fault.
  • Metadatos con significado propio: las características de una definición de metadatos son lo que todo uso de ella debe indicar, y sus restricciones deben cumplirse para ellas. Con metadata def SafetyRating { attribute level : Natural; assert constraint { level >= 1 and level <= 4 } }, la comprobación informa de @SafetyRating; (sin nivel) y de @SafetyRating { level = 7; } (fuera del rango); @SafetyRating { level = 4; } es correcto. Una característica con un valor o un default en la definición, o declarada [0..1], se puede omitir. Cada valor debe ajustarse al tipo de su característica: true o false para un Boolean, texto entre comillas para un String, un número entero para un Integer (0 o más para un Natural, mayor que 0 para un Positive) y, para una enumeración, uno de sus valores, como HazardAnalysis::fmea; la comprobación informa de cualquier otro valor, y de un valor predeterminado de la definición que no se ajuste. Un cuerpo de metadatos solo da valores a las características de la definición (level = 4;), y una abstract metadata def no se puede aplicar. La demostración Hybrid Car califica su controlador con @SafetyRating { level = 4; } y registra la revisión de la batería como @SafetyReview { method = HazardAnalysis::fmea; closed = true; }. En el Editor, Insertar ▾ → Definición de metadatos inicia una definición con una característica y una regla, y Aplicar metadatos aplica una dentro de un cuerpo. Sin escribir texto: seleccione una definición o un uso y use la sección Metadatos del inspector. Añadir metadatos aplica una de las definiciones de metadatos del proyecto; cada característica tiene entonces un campo (una lista de los valores para una enumeración o un Boolean, texto sin formato para un String, que Holarch escribe entre comillas; el valor predeterminado de la definición aparece como sugerencia, y una característica sin él se marca como obligatoria); los hallazgos de la comprobación para esos metadatos aparecen debajo; Quitar los elimina. Cada cambio se puede deshacer con un solo Deshacer. Los metadatos de la biblioteca estándar y los propios de Holarch (simulación, objetivos, variabilidad) tienen sus propios controles y no aparecen ahí.

Individuos, instantáneas y segmentos temporales

Un individual es una cosa concreta a lo largo de toda su vida, como un coche con su número de serie, en lugar de un tipo de cosa. Una instantánea (snapshot) es esa cosa en un instante; un time slice es un periodo de su vida. Ambos pertenecen a la ocurrencia que los posee y tienen sus características, de modo que pueden dar a esas características sus propios valores.

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 va antes de la palabra clave del tipo (individual part def, individual item def) o va sola (individual def Plate_77;). Un uso escrito individual está tipado por exactamente una definición individual: individual car1 : Car_VIN1234;.
  • snapshot y timeslice van antes de una palabra clave de tipo o solos, dentro de una parte, un item, una acción u otra ocurrencia. then timeslice secondOwner; ordena un time slice después del miembro anterior.
  • Un valor dentro de una instantánea o un time slice se lee primero ahí, después en el individual y después en su definición. En el ejemplo, atService.mileage es 15.000 km y la restricción se cumple.
  • Solo las ocurrencias pueden ser individuales, instantáneas o time slices: los atributos y las enumeraciones son valores.
  • En Arquitectura → Partes y en las vistas Base de datos y Cuadrícula, la columna Instancias enumera los individuales de la definición de cada parte (para part sedan : Car: Car_VIN1234): las definiciones individuales que la especializan y los usos individuales que tipa. Individual (Sí) y Porción (Instantánea o Time slice) también son columnas (Columnas ▾ → SysML v2). Partes muestra Instancias de forma predeterminada en cuanto el modelo tiene un individual, y la exportación Tabla (CSV) incluye entonces las tres columnas; la exportación Definiciones las enumera para cada elemento que las tiene.
  • En el inspector, Ocurrencia, en Características, establece Individual y, para los usos, Toda la vida, Time slice o Instantánea. El filtro de tipos del Navegador tiene Individuales, y el menú ⋯ de una fila tiene Nuevo snapshot… y Nuevo time slice…. La vista general muestra «individual part def», «snapshot» y «timeslice» en los encabezados de los cuadros, enumera las instantáneas y los time slices de un cuadro en su propio compartimento y dibuja las sucesiones entre cuadros como flechas discontinuas; Organizar ▾ → Organizar como línea de tiempo los alinea de izquierda a derecha. En la demostración Hybrid Car, la vista general carLifeline muestra las instantáneas y el time slice de Car_VIN1234.

Variaciones, variantes y configuraciones

Una variación enumera las opciones permitidas en un punto de un diseño; cada opción es una variante. Una definición de variación (variation part def) es un conjunto de opciones reutilizable; un uso de variación (variation part charger) es un punto dentro de un diseño. Una configuración elige una variante para cada punto.

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;
}
  • Una variante tiene las características de su variación y puede redefinirlas: largePack tiene una capacity porque BatteryPack es una Battery.
  • variant x; sin palabra clave de tipo convierte el uso existente x en una de las opciones; recibe el nombre de x.
  • Una variación solo posee variantes (y definiciones, comentarios, metadatos e importaciones). Una variación ya es abstracta, por lo que abstract en ella se señala como redundante.
  • Elija una variante con un valor: part :>> pack = BatteryPack::largePack;. Una elección que no es una variante de ese punto es un error.
  • Mientras un punto no tiene elección, su valor es desconocido, de modo que una aserción sobre él ni se cumple ni se incumple. En una configuración se usan los valores de las variantes elegidas.
  • Marque una configuración con @HolarchConfiguration (paquete HolarchVariability, en la Biblioteca estándar bajo Holarch): el Editor indica entonces cada punto que aún no ha elegido.
  • En el Editor, Insertar ▾ escribe cada uno de estos: Variación (una definición a nivel de paquete, un punto dentro de una parte), Variante (dentro de una variación), Configuración y Elección de variante (dentro de una configuración).
  • En la demostración Hybrid Car, CarLine tiene dos puntos (pack y charger), y selfChargingHybrid y plugInHybrid son configuraciones suyas; la aserción excluye un wallbox con el paquete de baterías estándar.

Representaciones textuales

Una representación textual escribe un elemento en otro lenguaje: rep language "Python" /* … */ dentro del cuerpo del elemento. El cuerpo se conserva como texto. El modelo es lo que declara el SysML que lo rodea; Holarch nunca ejecuta un cuerpo.

  • En la demostración Hybrid Car, DriveWheels lleva su cálculo en Python: rep language "Python" /* wheel_speed = torque.value * GEAR_RATIOS[gear] / WHEEL_RADIUS */.
  • Un cuerpo en "sysml" o "kerml" se comprueba. SpeedLimit está escrito como rep language "sysml" /* speed <= limit */, y Holarch lo evalúa como una restricción escrita directamente.
  • El Editor resalta los cuerpos SysML y KerML como código sobre un fondo tintado. Los demás lenguajes se muestran como texto de comentario.
  • La sección Representación del inspector enumera cada representación con su Lenguaje y su cuerpo. Haga clic en Añadir representación en una definición o un uso para añadir una, y en Quitar para eliminarla.
  • La vista de flujo de acciones marca una acción cuya definición tiene una representación con su lenguaje entre llaves, como {Python}.
  • Lenguajes conocidos: SysML, KerML, OCL, Alf, Python, JavaScript, MATLAB, Modelica, C y lenguaje natural (naturalLanguage, English, text). Una versión después del nombre se ignora (OCL2.0, Python 3).
  • Un cuerpo no puede contener */, que terminaría el comentario.

Los comentarios de debate, las etiquetas, los asignados y las fechas límite propios de Holarch se guardan junto al modelo. No se escriben en el texto.

Cómo usarlo

Modelar una estructura

  1. En el Editor, abra un paquete (o haga clic en + Nuevo package).
  2. Escriba una port def para cada tipo de punto de conexión, con características dirigidas (out attribute torque : TorqueValue;).
  3. Escriba una part def para cada tipo de componente, con sus atributos y puertos.
  4. Escriba una part def para el conjunto, con una part para cada componente.
  5. Conecte las partes: connect a.p to b.q;, o interface name : Def connect a.p to b.q;.
  6. Deje de escribir. La línea de estado dice Aplicado y el Navegador muestra los nuevos elementos.

Insertar ▾ (o ⌃⇧Space / Ctrl+Shift+Space) escribe cada una de estas construcciones por usted, con campos que completar. Consulte Insertar una construcción.

Dar valores con unidades

  1. Importe los tipos de magnitud y las unidades al principio del paquete: private import ISQ::*; y private import SI::*;.
  2. Tipe el atributo mediante un tipo de magnitud y dele un valor: attribute mass : MassValue = 45 [kg];.
  3. En una definición que hereda el atributo, redefínalo con su propio valor: attribute redefines mass = 18 [kg];.
  4. Señale el valor. Aparece una tarjeta de error si la unidad no corresponde al tipo de magnitud.

Describir el comportamiento

  1. Escriba una action def con sus parámetros in y out.
  2. Añada un paso por cada uso action y ordénelos con first … then …; o then.
  3. Use fork y join para pasos en paralelo, y decide y merge para alternativas.
  4. Añada flow of Item from a.out to b.in; entre los pasos que se pasan items.
  5. En la parte que lleva a cabo el comportamiento, escriba perform action name : Def; y, en sus partes, perform name.step;.
  6. Abra la acción en una vista de flujo de acciones para verla dibujada (consulte Vistas de SysML v2).

Escribir un requisito y trazarlo

  1. Escriba requirement <'ID'> name { doc /* The system shall … */ subject s : Def; }.
  2. Añada require constraint { … } cuando el requisito se pueda comprobar con valores.
  3. Escriba satisfy name by somePart; donde el diseño lo cumple.
  4. Escriba una verification cuyo objetivo lo verifique con verify.
  5. Abra Necesidades y requisitos → Requisitos: el requisito aparece con su número, y Verificación → RVTM muestra cómo se verifica. Consulte Requisitos y verificación en proyectos SysML v2.

Marcar un valor como TBD o TBR

Escribir TBD en lugar de un valor no es SysML válido. Use en su lugar los metadatos de Holarch.

  1. Impórtelos: private import HolarchMetadata::*;.
  2. Ponga un prefijo al atributo: #TBD attribute chargerPower : PowerValue; (todavía sin valor) o #TBR attribute limit : TimeValue = 0.5 [h]; (un valor que revisar).
  3. Para registrar un responsable y un motivo, escriba la forma larga en el cuerpo del atributo: @TBD { owner = "Powertrain lead"; rationale = "The charging standard is not chosen yet."; due = "2026-12-01"; }.

El registro de TBD/TBR enumera estos valores. TBD y TBR especializan ModelingMetadata::StatusInfo, de modo que otras herramientas SysML v2 los leen como anotaciones de estado. Insertar ▾ → Valor TBD y Valor TBR los escriben por usted.

Buscar un nombre de la biblioteca

  1. Abra la Biblioteca estándar desde las herramientas de la barra de navegación.
  2. Escriba parte del nombre en Buscar un package o una definición…, por ejemplo MassValue.
  3. Haga clic en Copiar nombre en la fila. Se copia el nombre cualificado, aquí ISQBase::MassValue.
  4. Péguelo en el Editor, o importe su paquete y use el nombre corto.

Ejemplo práctico: leer el requisito del sedán

Este ejemplo sigue un requisito a lo largo del texto de la demostración Hybrid Car.

  1. Abra la demostración y elija VehicleRequirements en la lista Paquetes del Editor.
  2. Busque requirement def <'VR-1'> CurbMass. Su require constraint { car.curbMass <= limit } compara la masa en vacío del sujeto con limit.
  3. Busque requirement carSpec. Contiene requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }. El uso redefine limit con el objetivo a nivel de paquete maxCurbMass = 1650 [kg].
  4. Busque satisfy carSpec by fleet.sedan;. Haga clic con ⌘ / Ctrl en sedan: el Editor abre Vehicles en part sedan : Car, donde attribute redefines curbMass = 1580 [kg]; da el valor.
  5. De vuelta en VehicleRequirements, busque verification def CurbMassTest. Su objetivo verify carSpec.sedanMass; lo convierte en un caso de verificación de VR-1.1, y verification sedanWeighing : CurbMassTest { subject car = fleet.sedan; } lo aplica al sedán.
  6. Cambie 1580 [kg] por 1700 [kg] en Vehicles y deje de escribir. El sedán supera ahora el límite de 1650 kg, y el Editor muestra en VehicleRequirements un aviso de que sedan no cumple el requisito, con la restricción falsa y sus valores. Deshaga con ⌘Z / Ctrl+Z.

Consejos y errores comunes

  • «…» no está definido aquí. El nombre está mal escrito o su paquete no está importado. Añada private import Package::*;, o escriba el nombre cualificado.
  • Falta un ;. Cada declaración termina con ; o con un cuerpo { … }. The declaration does not end. Add ; or a { … } body. (La declaración no termina. Añada ; o un cuerpo { … })
  • :> frente a :>>. Use :> para especializar o crear un subconjunto; use :>> para sustituir una característica heredada. Redefinir una característica que no se hereda da «x» no se hereda en «y».
  • Las unidades necesitan importaciones. 5 [kg] solo se resuelve donde SI es visible.
  • Dos miembros con un mismo nombre. «x» ya se usa en este espacio de nombres. Cambie el nombre de uno; una variante redefine en su lugar.
  • verify fuera de un objetivo. Póngalo en objective { verify R; } de un caso de verificación.
  • Palabras clave como nombres. Palabras como part, state o action están reservadas. Póngalas entre comillas ('state') o elija otro nombre.

Qué admite Holarch

Holarch admite las siguientes partes de la notación textual de SysML v2. El Editor las comprueba todas y el modelo las conserva.

ÁreaAdmitido
Paquetes y espacios de nombrespackage, paquetes anidados, library package (solo lectura), doc, comment … about, notas // y //* */, alias … for …, public/private/protected, nombres cortos <'1.2'>, nombres entre comillas
Importacionesimportaciones de miembros y de espacios de nombres, ::*, recursivas ::**, importaciones filtradas [@Kind]
Definiciones y usospart, 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
Especialización:>/specializes, :/defined by, :>/subsets, :>>/redefines, conjugación ~, disjoint, cadenas de características a.b.c
Multiplicidades[n], [n..m], [*], [0..*], ordered, nonunique, expresiones como límites
Valores y unidades=, :=, default, magnitudes 5 [kg], expresiones de unidades [m/s^2], los tipos de magnitud ISQ y las unidades SI y de uso habitual en EE. UU. de la biblioteca estándar, comprobaciones de dimensiones
Estructurapuertos y puertos conjugados, connect, interfaces con extremos, extremos de conector con nombre y multiplicidades, bind, flow of T from … to …, message
Accionesparámetros, perform, sucesiones (first … then …, then), fork, join, decide, merge, guardas, accept, send, assign, if, while, for, loop, start, done, terminate
Estadosentry/do/exit, transiciones con disparador, guarda y efecto, estados parallel, estados anidados, exhibit
Requisitossubject, actor, stakeholder, require constraint, assume constraint, frame concern, satisfy … by …, verify, nombres cortos como identificadores, doc como texto del requisito
Restricciones y cálculosdefiniciones y usos de restricciones y cálculos, return, assert constraint, llamadas, expresiones KerML con aritmética, comparación, lógica, if ? else y operaciones de secuencia, evaluación con unidades
Casos de uso, análisis y verificaciónsubject, actor, objective, include use case, casos de análisis con un resultado return, casos de verificación con verify y un veredicto
Vistasview, view def, expose (con ::*, ::** y filtros), filter, viewpoint, frame, render, las definiciones de vista estándar
Asignación y trazasallocate a to b, definiciones de asignación, dependency from … to …
Individualesdefiniciones y usos individual, snapshot y timeslice (también después de then), sus valores y sucesiones
Variabilidaddefiniciones y usos variation, miembros variant y referencias de variante (variant x;), elecciones por valor, configuraciones marcadas con @HolarchConfiguration (HolarchVariability)
Metadatos@Name { … }, el prefijo #Name, metadata Name about …, los paquetes HolarchMetadata (TBD, TBR) y HolarchFrameworks de Holarch; metadata def definidas por el usuario; palabras clave definidas por el usuario y metadatos semánticos (#fault def …)

Se conserva tal como está escrito, sin interpretarlo

Holarch lee y conserva estas construcciones exactamente como están escritas, pero no les da ningún significado propio:

  • representaciones textuales en lenguajes distintos de SysML y KerML (se conservan como texto; consulte Representaciones textuales).

Aún no disponible

  • Importar archivos KerML (.kerml).
  • Confirmar cambios en main, etiquetas y fusiones a través de la Systems Modeling API: otras herramientas confirman cambios en ramas de solicitudes de cambio, que un aprobador aplica en Holarch (consulte La API y MCP en proyectos SysML v2).
  • Extensiones del lenguaje más allá de las palabras clave definidas por el usuario y los metadatos semánticos.

Comprobaciones

Holarch comprueba el texto mientras escribe. Cada problema se marca en el margen del Editor y se subraya; el mensaje indica el problema y después la solución. Los errores impiden que se aplique un miembro; los avisos no.

ÁreaQué se compruebaMensaje de ejemplo
SintaxisCaracteres, comentarios, cadenas, llaves, ;, nombres y tokens esperadosEsta llave no tiene pareja. Añada la { o } correspondiente, o elimine esta.
NombresNombres sin resolver, ambiguos, no válidos, duplicados (aviso) y privados«Batery» no está definido aquí. Compruebe la ortografía o importe su paquete.
Tipado y especializaciónCiclos; tipado y especialización mediante una definición del tipo correcto; subconjuntos y redefinición de características; redefinición solo de características heredadas«capacity» no se hereda en «Car». Especialice su tipo, o cree un subconjunto con :> en su lugar.
MultiplicidadesLímites válidos y enteros; una redefinición no más amplia que lo que redefineLa multiplicidad [3..1] no es válida. Use un límite inferior entre 0 y el límite superior.
Unidades y valoresDimensiones coincidentes, unidades que faltan, nombres de unidades, tipos de númeroLas unidades no coinciden: kg y s. Convierta un lado a una unidad compatible.
ExpresionesSintaxis, tipos de operandos, argumentos de cálculos, condiciones booleanasLa condición debe ser verdadera o falsa; es un número. Escriba una comparación como x > 0.
EstructuraLos extremos de conexión son características, las interfaces conectan puertos, direcciones de puertos, flujos y mensajes, tipos de items de flujo, tipos de enlaceEstas direcciones de puerto no encajan. Conjugue un puerto (~) o cambie una dirección.
AccionesSucesiones entre acciones del mismo cuerpo, número de entradas y salidas de los nodos de control, guardas de decisión y else, start y done, asignaciones, destinos de perform, los valores que recorre un bucle for frente al tipo de la variable del buclethen necesita una acción anterior. Añada una acción o first … then ….
EstadosTransiciones entre estados del mismo cuerpo, un entry/do/exit de cada, transiciones iniciales, regiones paralelas, destinos de exhibit, el efecto do de una transición (send a algo que puede recibir, assign, accept, action o una acción con nombre), la carga útil de un disparador frente a los items de su puerto, un disparador sobre un valor de biblioteca sin más, como Real (aviso), disparadores at que nombran un tiempo«electric» tiene subestados pero ninguna transición inicial, por lo que no se entra en ninguno. Añada entry; then <first state>;.
Requisitos, casos y vistasMiembros en el lugar correcto, un solo sujeto, destinos de satisfy/verify/require, tipos de sujeto, destinos de expose e import, destinos de frameverify va en el objetivo de un caso de verificación. Muévalo a objective { … }.
Representaciones textualesLos cuerpos SysML y KerML se analizan y declaran el elemento que representan; los lenguajes desconocidos se señalanLa representación de «SpeedLimit» declara una definición de part, no una definición de restricción. Haga que el cuerpo declare el propio «SpeedLimit».
Individuos, instantáneas y segmentos temporalesindividual solo en ocurrencias y con exactamente una definición individual; snapshot/timeslice solo en usos de ocurrencia dentro de una ocurrencia; un time slice dentro de una instantánea (aviso)«parked» es individual, pero ninguna de sus definiciones lo es. Tipéelo mediante una definición individual, o quite individual.
VariabilidadUna variación solo posee variantes; una variante está en una variación y es de su tipo; una elección es una variante de su punto; abstract en una variación es redundante (nota); los puntos abiertos de una configuración (nota)«compact» no es una variante de «pack». Elija uno de estos: standardPack, largePack.
Palabras clave definidas por el usuario#Name nombra una definición de metadatos; una declaración sin palabra clave del lenguaje usa metadatos semánticos (aviso); los metadatos solo marcan los tipos que permite su annotatedElement; un tipo base semántico es una definición o un uso, corresponde al elemento que marca (aviso) y no forma ningún ciclo«safetyCritical» se aplica a PartDefinition, no a «invert» (ActionUsage). Muévalo o quítelo.
Valores de metadatosToda característica obligatoria de una definición de metadatos definida por el usuario recibe un valor (aviso); cada valor y valor predeterminado se ajusta al tipo de su característica (Boolean, String, números enteros, enumeraciones); las restricciones de la definición se cumplen para los valores dados; un cuerpo de metadatos solo redefine las características de la definición; las definiciones de metadatos abstractas no se aplican; metadatos semánticos escritos con about (aviso)Los valores de «SafetyRating» incumplen su restricción levelRange: level >= 1 and level <= 4. Cambie los valores.
EvaluaciónRestricciones, requisitos y objetivos que no se cumplen con los valores actuales«sedan» no cumple «sedanMass»: … es falso (…). Cambie los valores del diseño o el requisito.

La Biblioteca estándar

La página Biblioteca estándar enumera los paquetes y las definiciones que todo proyecto SysML v2 puede usar: valores y unidades, magnitudes, partes, puertos, acciones, estados, requisitos, análisis y más. Es de solo lectura.

  • Ábrala desde Ajustes → Biblioteca estándar en las herramientas de la barra de navegación. Los proyectos LML no la tienen.
  • Carpetas. El lado izquierdo enumera los archivos de la biblioteca por carpeta: Kernel Libraries, Systems Library, Domain Libraries (Analysis, Cause and Effect, Geometry, Metadata, Quantities and Units, Requirement Derivation) y Holarch (el paquete HolarchMetadata con TBD y TBR, HolarchVariability con HolarchConfiguration, y HolarchRequirements con Objective).
  • Un archivo. Seleccione un archivo para ver sus paquetes, cada uno con su documentación y una tabla de sus definiciones: Nombre, Tipo y Documentación.
  • Buscar. Escriba en Buscar un package o una definición… para buscar en los nombres y la documentación de todos los archivos. Los resultados muestran el archivo; haga clic en él para abrirlo. Pulse Esc para borrar.
  • Copiar nombre copia el nombre cualificado de un elemento, como ISQ::MassValue, para usarlo en el Editor.
  • Mostrar texto muestra el archivo de la biblioteca tal como está escrito; Mostrar definiciones vuelve a las tablas.

La biblioteca es la biblioteca de la versión publicada de SysML v2, con una corrección: una tonne (alias 'metric ton') equivale a 1000 kg; el archivo publicado dice 0,001 kg. Su modelo hace referencia a ella por su nombre; no se copia en el proyecto ni forma parte de una exportación .sysml.

Límites

  • Un documento de texto de más de 8 MB no se comprueba: This text is larger than 8 MB and is not checked. Split it into several packages. (Este texto ocupa más de 8 MB y no se comprueba. Divídalo en varios paquetes)
  • Una línea de más de 64 KB no se comprueba.
  • Un anidamiento de más de 256 niveles no se comprueba.
  • La biblioteca estándar no se puede editar.

SysML® y OMG® son marcas registradas de Object Management Group, Inc. en los Estados Unidos y otros países.