Holarch

SysML v2

Notação textual SysML v2

A linguagem SysML v2 como o Holarch a suporta, com exemplos da demonstração Hybrid Car, as checagens que ele executa e a Standard Library somente leitura.

Como usá-lo →

Nesta página
  1. Visão geral
  2. Conceitos
    1. Elementos, proprietários e nomes qualificados
    2. Pacotes
    3. Imports e visibilidade
    4. Definições e usos
    5. Tipagem, especialização e redefinição
    6. Multiplicidades
    7. Valores e unidades
    8. Estrutura: portas, conexões, interfaces, vinculações e fluxos
    9. Comportamento: ações
    10. Comportamento: estados
    11. Requisitos, restrições e verificação
    12. Casos de uso
    13. Visões
    14. Comentários, documentação e metadados
    15. Indivíduos, snapshots e fatias de tempo
    16. Variações, variantes e configurações
    17. Representações textuais
  3. Como usá-lo
    1. Modelar uma estrutura
    2. Dar valores com unidades
    3. Descrever o comportamento
    4. Escrever um requisito e rastreá-lo
    5. Marcar um valor como TBD ou TBR
    6. Encontrar um nome da biblioteca
  4. Exemplo prático: ler o requisito do sedã
  5. Dicas e erros comuns
  6. O que o Holarch suporta
    1. Mantido como escrito, não interpretado
    2. Ainda não disponível
  7. Checagens
  8. A Biblioteca padrão
  9. Limites
  10. Páginas relacionadas

Visão geral

O SysML v2 descreve um sistema como uma árvore de elementos nomeados, escrita como texto. O Holarch suporta a notação textual SysML v2, baseada na especificação SysML v2 da OMG. Você escreve o texto no Editor, e o Holarch mostra os mesmos elementos no Navegador, nas visões, nas tabelas e nas páginas do ciclo de vida.

Esta página ensina a notação com exemplos da demonstração Hybrid Car (SysML v2). Em seguida, lista o que o Holarch suporta, as checagens que ele executa no seu texto e a Biblioteca padrão.

Conceitos

Elementos, proprietários e nomes qualificados

Todo elemento tem um proprietário, exceto os pacotes de nível superior. O nome qualificado de um elemento é a cadeia dos nomes de seus proprietários, unidos por ::. Na demonstração, a bateria da definição do trem de força é Vehicles::Powertrain::battery.

Um nome com espaços ou outros caracteres especiais vai entre aspas simples: 'Fuel Tank'. Um nome curto entre sinais de menor e maior dá a um elemento um segundo identificador, curto: requirement def <'VR-1'> CurbMass. O Holarch usa o nome curto de um requisito como seu número.

Pacotes

Um pacote agrupa elementos, como uma pasta. Pacotes podem ser aninhados. Cada pacote de nível superior é um documento no Editor.

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

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

Imports e visibilidade

Um import torna os membros de outro pacote visíveis por seus nomes curtos.

  • import ISQ::*; importa os membros de ISQ.
  • import VehicleRequirements::**; importa também os membros dos elementos aninhados (recursivo).
  • import Vehicles::Car; importa um elemento.
  • import Vehicles::*[@SysML::PartDefinition]; importa apenas os membros de um tipo (um import filtrado).

private, protected e public definem quem mais vê um membro ou um import. A demonstração escreve private import para que os imports não passem adiante para pacotes que, por sua vez, o importam.

Sem um import, escreva o nome qualificado: ISQ::MassValue é resolvido em qualquer lugar, MassValue apenas onde ISQ é importado.

Um alias dá a um elemento um segundo nome: alias Hybrid for Car;.

Definições e usos

Uma definição descreve um tipo de coisa. Um uso é uma utilização de uma definição dentro de outro elemento. A maioria das palavras-chave existe nas duas formas:

DefiniçãoUsoO que é
part def Battery;part battery : Battery;Um sistema, subsistema ou componente
attribute def TirePressure;attribute mass : MassValue = 45 [kg];Um valor, muitas vezes com unidades
item def Fuel;item fuel : Fuel;Algo que flui ou é manipulado
port def FuelPort { … }port fuelOut : FuelPort;Um ponto de conexão em uma part
connection def … / interface def FuelLine { … }interface fuel : FuelLine connect …;Um vínculo entre parts ou portas
action def ProduceTorque { … }action produce : ProduceTorque;Comportamento: uma etapa que recebe entradas e produz saídas
state def PowertrainStates { … }state off;Comportamento: um estado e suas transições
constraint def MassLimit { … }constraint …;Uma condição booleana sobre valores
calc def PowerToWeight { … }calc …;Um cálculo com um valor return
requirement def <'VR-1'> CurbMass { … }requirement <'VR-1.1'> sedanMass : CurbMass;Um requisito
use case def DriveToWork { … }use case commute : DriveToWork;Um caso de uso
analysis def PowerToWeightAnalysis { … }analysis sedanPowerToWeight : …;Um caso de análise
verification def CurbMassTest { … }verification sedanWeighing : CurbMassTest;Um caso de verificação
view def RequirementsView { … }view driveCycleFlow : ActionFlowView { … }Uma visão do modelo
enum def DriveMode { … }attribute mode : DriveMode;Um conjunto fixo de valores

Os membros aninhados em uma definição pertencem a todos os seus usos. part frontAxle : Axle; tem differential, leftWheel e rightWheel de Axle sem repeti-los.

Tipagem, especialização e redefinição

Quatro operadores relacionam definições e usos. Cada um tem também uma forma de palavra-chave.

OperadorPalavra-chaveSignificadoExemplo
:defined byTipa um uso por uma definiçãopart engine : Engine;
:> em uma definiçãospecializesA definição é um tipo da outra e herda seus membrospart def FuelTank :> Component
:> em um usosubsetsO uso é um subconjunto de outro usopart spareWheel :> wheels;
:>>redefinesSubstitui um uso herdado, por exemplo para dar-lhe um valorattribute redefines mass = 18 [kg];
~Conjuga uma porta: suas features in e out trocam de lugarport fuelIn : ~FuelPort;

A redefinição é a forma como uma variante ou uma part configurada altera o que herda. Na demonstração, SportCar remove o estepe por redefinição:

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

abstract marca uma definição que não tem instâncias diretas (abstract part def Component). ref marca uma referência que não é possuída. in, out e inout definem a direção de uma feature ou de um parâmetro. end marca as extremidades de uma definição de conexão ou de interface.

Multiplicidades

Uma multiplicidade entre colchetes diz quantos existem.

  • [2]: exatamente dois. part runabout : CityCar [2];
  • [0..1]: opcional. part spare : Wheel [0..1];
  • [1..*] e [*]: um ou mais, qualquer número.
  • [0]: nenhum, usado para remover uma part herdada.
  • Os limites podem ser expressões. ordered e nonunique vêm depois dos colchetes.

Valores e unidades

= vincula um valor. := dá um valor inicial que pode mudar. default dá um padrão que uma redefinição pode substituir.

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

Uma grandeza é um número com uma unidade entre colchetes. As unidades se combinam com *, / e ^ ([m/s^2]). Tipos de grandeza como MassValue vêm de ISQ, e unidades como kg vêm de SI (ou USCustomaryUnits). O Holarch checa as dimensões: atribuir 5 [s] a um MassValue é um erro.

As expressões usam aritmética, comparação (<=, ==), operadores lógicos (and, or, not, implies), a condicional if c ? a else b, cadeias de features (car.powertrain.battery.capacity), chamadas de cálculos (PowerToWeight(power, mass)) e operações de sequência como ->sum, ->size, ->select e ->collect. O Holarch as avalia com unidades para valores, restrições, visões e páginas de análise.

Estrutura: portas, conexões, interfaces, vinculações e fluxos

As parts se conectam por meio de suas portas.

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 duas parts ou portas.
  • Uma interface é uma conexão tipada entre portas. Sua definição nomeia suas extremidades: interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  • Cada extremidade de uma conexão ou interface pode ter um nome e uma multiplicidade: interface motorShaft : Shaft connect [1] driver ::> motor.output to [1] driven ::> transmission.motorIn;. Uma extremidade nomeada é uma feature da conexão, então motorShaft.driver se refere a ela.
  • bind a = b; diz que duas features são a mesma (um binding connector).
  • flow of Fuel from supply.fuel to produce.fuel; leva um item de uma feature para outra. message envia um item entre parts como um evento.

Comportamento: ações

Uma definição de ação contém suas etapas (usos de ação), seus parâmetros e a ordem das etapas.

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;
}
  • As sucessões ordenam as etapas: first a then b;, ou then b; logo depois de a. start e done são o início e o fim.
  • Nós de controle: fork e join para caminhos paralelos; decide e merge para alternativas. Uma sucessão com guarda depois de uma decisão se escreve if speed > 30 then cruise;, e else brake; é o ramo padrão.
  • Encerrar: terminate; encerra imediatamente a ação que a contém, com todas as suas etapas ainda em execução; then terminate; a coloca depois da etapa anterior. terminate x; encerra a ocorrência x.
  • Outras ações: accept espera um sinal, send envia um, assign x := expr; altera um valor, if executa um bloco ou o pula, while … { … } until …; e for v in seq { … } repetem um bloco.
  • Alocação de comportamento: uma part executa uma ação com perform (perform action trip : DriveCycle;, perform trip.supply;), e allocate a to b; aloca um elemento a outro.

Comportamento: estados

Uma definição de estado contém estados e as transições entre eles.

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; define o estado inicial.
  • As transições têm um gatilho (accept StartRequest), uma guarda opcional (if charge > 20) e um efeito opcional (do …). A forma curta vem depois do estado de origem; a forma longa é transition name first a … then b;.
  • No modelo, o gatilho e o efeito de uma transição são elementos próprios: uma ação accept e uma ação (send, assign, perform, terminate ou uma ação nomeada). O Navegador os mostra como trigger e effect abaixo da transição. Eles são o accepter e o effect da própria transição, então outras partes do modelo podem nomeá-los: chargerStates.plugIn.effect.sentMessage é a mensagem que o efeito envia, como um modelo de sequência a vincula.
  • Um gatilho por meio de uma porta precisa aceitar algo que a porta transporta: no ChargeManager da demonstração, accept connectCharger : ChargerConnected via chargePort corresponde a in connected : ChargerConnected da porta. O efeito send new ChargeRequest() to controller envia para uma part; um valor como um atributo não pode receber uma mensagem.
  • As ações entry, do e exit são executadas ao entrar no estado, enquanto se está nele e ao sair dele. Estados parallel têm regiões que ficam todas ativas ao mesmo tempo.
  • Uma part exibe um estado com exhibit: exhibit state powertrainStates : PowertrainStates;.

Requisitos, restrições e verificação

Um requisito contém sua declaração em doc, o elemento a que se aplica como subject e uma condição checável 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 declara uma condição que o requisito pressupõe. Quando ela não vale, esse requisito e os requisitos aninhados nele contam como atendidos; o requisito ao redor e os outros requisitos aninhados continuam sendo checados. actor, stakeholder e frame concern nomeiam para quem e para quê o requisito existe.
  • satisfy R by part; diz que uma part atende a um requisito.
  • Um caso de verificação verifica requisitos em seu objetivo: objective { verify carSpec.sedanMass; }. Ele pode ter return verdict : Boolean = …;.
  • Um caso de análise tem um sujeito, um objetivo e um resultado return que o Holarch avalia quando todas as entradas têm valor. Os atributos do caso sem valor são resolvidos a partir das equações == do seu objetivo (Casos de análise com incógnitas).
  • connection : Derivation connect original to derived; registra um requisito derivado. #refinement dependency x to R; registra um refinamento.
  • dependency from a to b; registra um rastro geral.

Casos de uso

use case def DriveToWork { subject car : Car; actor driver : Driver; objective { … } include use case startCar : StartCar; }. Um uso de caso de uso recebe o sujeito e os atores da sua definição.

Visões

Uma visão mostra parte do modelo. Ela é tipada por uma definição de visão padrão e expõe com expose o que mostra:

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

filter restringe os elementos (filter @SysML::RequirementUsage;). render escolhe uma renderização. Um viewpoint enquadra as preocupações que uma visão precisa atender. Vistas SysML v2 explica cada tipo de visão.

Comentários, documentação e metadados

  • doc /* text */ documenta seu proprietário. Faz parte do modelo; para um requisito, é o texto do requisito.
  • comment about x /* text */ é uma nota no modelo sobre outro elemento.
  • // text e //* text */ são notas apenas no texto. O Holarch as mantém no texto, mas elas não são elementos do modelo.
  • Metadados anotam um elemento: @TBD { owner = "Powertrain lead"; } em um corpo, #TBR attribute limit … como prefixo, ou metadata Capability about Vehicles::Car; de fora.
  • Palavras-chave definidas pelo usuário: qualquer definição de metadados funciona como palavra-chave: #safetyCritical part controller : Controller; marca o controlador com os metadados SafetyCritical (nome curto <safetyCritical>). Uma definição de metadados pode limitar o que marca: :>> annotatedElement : SysML::PartDefinition; permite apenas definições de part.
  • Metadados semânticos: uma definição de metadados que especializa SemanticMetadata define um tipo base, :>> baseType = faults meta SysML::Usage;. Todo elemento que ela marca passa então a especializar a base: um uso é subconjunto de um uso base, uma definição especializa uma definição base ou as definições de um uso base. Assim, #fault def BatteryOverheat; e #fault overheat : BatteryOverheat; são faults e têm as features de Fault. Com metadados semânticos, a palavra-chave da linguagem pode ser omitida, como nessas duas linhas; o Navegador os mostra com sua palavra-chave (#fault def). Escrito de fora, metadata Fault about x; não torna x uma fault: a checagem emite um aviso e sugere marcar o próprio x com #fault.
  • Metadados com significado próprio: as features de uma definição de metadados são o que todo uso dela precisa informar, e suas restrições precisam valer para elas. Com metadata def SafetyRating { attribute level : Natural; assert constraint { level >= 1 and level <= 4 } }, a checagem aponta @SafetyRating; (sem nível) e @SafetyRating { level = 7; } (fora do intervalo); @SafetyRating { level = 4; } está correto. Uma feature com um valor ou default na definição, ou declarada [0..1], pode ser omitida. Cada valor precisa caber no tipo da sua feature: true ou false para um Boolean, texto entre aspas para um String, um número inteiro para um Integer (0 ou mais para um Natural, acima de 0 para um Positive) e, para uma enumeração, um de seus valores, como HazardAnalysis::fmea; a checagem aponta qualquer outro valor, e também um padrão na definição que não cabe. Um corpo de metadados apenas dá valores às features da definição (level = 4;), e uma abstract metadata def não pode ser aplicada. A demonstração Hybrid Car classifica seu controlador como @SafetyRating { level = 4; } e registra a revisão da bateria como @SafetyReview { method = HazardAnalysis::fmea; closed = true; }. No Editor, Inserir ▾ → Definição de metadados inicia uma definição com uma feature e uma regra, e Aplicar metadados aplica uma dentro de um corpo. Sem escrever texto: selecione uma definição ou um uso e use a seção Metadados do inspetor. Adicionar metadados aplica uma das definições de metadados do projeto; cada feature passa a ter um campo (uma lista dos valores para uma enumeração ou um Boolean, texto simples para um String, que o Holarch escreve entre aspas; o padrão da definição aparece como dica, e uma feature sem padrão é marcada como obrigatória); as constatações da checagem para esses metadados aparecem abaixo dele; Remover os retira. Cada alteração pode ser revertida com um único Desfazer. Os metadados da biblioteca padrão e os do próprio Holarch (simulação, objetivos, variabilidade) mantêm seus próprios controles e não são listados ali.

Indivíduos, snapshots e fatias de tempo

Um indivíduo é uma coisa específica ao longo de toda a sua vida, como um carro com seu número de série, e não um tipo de coisa. Um snapshot é essa coisa em um instante; um time slice é um período da sua vida. Ambos pertencem à ocorrência que os possui e têm suas features, então podem dar a essas features valores próprios.

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 vem antes da palavra-chave do tipo (individual part def, individual item def) ou fica sozinha (individual def Plate_77;). Um uso escrito com individual é tipado por exatamente uma definição de indivíduo: individual car1 : Car_VIN1234;.
  • snapshot e timeslice vêm antes de uma palavra-chave de tipo ou ficam sozinhas, dentro de uma part, item, ação ou outra ocorrência. then timeslice secondOwner; ordena um time slice depois do membro anterior.
  • Um valor dentro de um snapshot ou time slice é lido primeiro ali, depois no indivíduo e depois na sua definição. No exemplo, atService.mileage é 15.000 km e a restrição vale.
  • Apenas ocorrências podem ser indivíduos, snapshots ou time slices: atributos e enumerações são valores.
  • Em Arquitetura → Parts, nas visões Banco de dados e Grade, a coluna Instâncias lista os indivíduos da definição de cada part (para part sedan : Car: Car_VIN1234): as definições de indivíduo que a especializam e os usos de indivíduo que ela tipa. Individual (Sim) e Porção (Instantâneo ou Time slice) também são colunas (Colunas ▾ → SysML v2). Parts mostra Instâncias por padrão assim que o modelo tem um indivíduo, e a exportação Tabela (CSV) passa a incluir as três colunas; a exportação Definições as lista para cada elemento que as tem.
  • No inspetor, Ocorrência em Features define Individual e, para usos, Vida inteira, Time slice ou Instantâneo. O filtro de tipo do Navegador tem Indivíduos, e o menu ⋯ de uma linha tem Novo snapshot… e Novo time slice…. A Visão geral mostra «individual part def», «snapshot» e «timeslice» nos cabeçalhos das caixas, lista os snapshots e time slices de uma caixa em um compartimento próprio e desenha as sucessões entre caixas como setas tracejadas; Organizar ▾ → Organizar como linha do tempo as alinha da esquerda para a direita. Na demonstração Hybrid Car, a Visão geral carLifeline mostra os snapshots e o time slice de Car_VIN1234.

Variações, variantes e configurações

Uma variação lista as escolhas permitidas em um ponto de um projeto; cada escolha é uma variante. Uma definição de variação (variation part def) é um conjunto reutilizável de escolhas; um uso de variação (variation part charger) é um ponto dentro de um projeto. Uma configuração escolhe uma variante para cada ponto.

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;
}
  • Uma variante tem as features da sua variação e pode redefini-las: largePack tem uma capacity porque BatteryPack é uma Battery.
  • variant x; sem palavra-chave de tipo torna o uso existente x uma das escolhas; ela recebe o nome de x.
  • Uma variação possui apenas variantes (e definições, comentários, metadados e imports). Uma variação já é abstrata, então abstract nela é apontado como redundante.
  • Escolha uma variante com um valor: part :>> pack = BatteryPack::largePack;. Uma escolha que não é uma variante desse ponto é um erro.
  • Enquanto um ponto não tem escolha, seu valor é desconhecido, então uma asserção sobre ele não é nem atendida nem violada. Em uma configuração, são usados os valores das variantes escolhidas.
  • Marque uma configuração com @HolarchConfiguration (pacote HolarchVariability, na Biblioteca padrão em Holarch): o Editor então aponta cada ponto que ela ainda não escolheu.
  • No Editor, Inserir ▾ escreve cada um destes: Variação (uma definição no nível do pacote, um ponto dentro de uma part), Variante (dentro de uma variação), Configuração e Escolha de variante (dentro de uma configuração).
  • Na demonstração Hybrid Car, CarLine tem dois pontos (pack e charger), e selfChargingHybrid e plugInHybrid são configurações dela; a asserção exclui um wallbox com o pack padrão.

Representações textuais

Uma representação textual escreve um elemento em outra linguagem: rep language "Python" /* … */ dentro do corpo do elemento. O corpo é mantido como texto. O modelo é o que o SysML ao redor declara; o Holarch nunca executa um corpo.

  • Na demonstração Hybrid Car, DriveWheels traz seu cálculo em Python: rep language "Python" /* wheel_speed = torque.value * GEAR_RATIOS[gear] / WHEEL_RADIUS */.
  • Um corpo em "sysml" ou "kerml" é checado. SpeedLimit é escrito como rep language "sysml" /* speed <= limit */, e o Holarch o avalia como uma restrição escrita diretamente.
  • O Editor destaca corpos SysML e KerML como código sobre um fundo colorido. Outras linguagens aparecem como texto de comentário.
  • A seção Representação do inspetor lista cada representação com sua Linguagem e seu corpo. Clique em Adicionar representação em uma definição ou um uso para adicionar uma, e em Remover para excluir uma.
  • A visão de fluxo de ações marca uma ação cuja definição tem uma representação com a linguagem entre chaves, como {Python}.
  • Linguagens conhecidas: SysML, KerML, OCL, Alf, Python, JavaScript, MATLAB, Modelica, C, linguagem natural (naturalLanguage, English, text). Uma versão depois do nome é ignorada (OCL2.0, Python 3).
  • Um corpo não pode conter */, que encerraria o comentário.

Os comentários de discussão, rótulos, responsáveis e prazos do próprio Holarch ficam ao lado do modelo. Eles não são escritos no texto.

Como usá-lo

Modelar uma estrutura

  1. No Editor, abra um pacote (ou clique em + Novo package).
  2. Escreva um port def para cada tipo de ponto de conexão, com features direcionadas (out attribute torque : TorqueValue;).
  3. Escreva um part def para cada tipo de componente, com seus atributos e portas.
  4. Escreva um part def para o conjunto, com uma part para cada componente.
  5. Conecte as parts: connect a.p to b.q; ou interface name : Def connect a.p to b.q;.
  6. Faça uma pausa. A linha de status diz Aplicado e o Navegador mostra os novos elementos.

Inserir ▾ (ou ⌃⇧Space / Ctrl+Shift+Space) escreve cada uma dessas construções para você, com campos a preencher. Consulte Inserir uma construção.

Dar valores com unidades

  1. Importe os tipos de grandeza e as unidades no início do pacote: private import ISQ::*; e private import SI::*;.
  2. Tipe o atributo por um tipo de grandeza e dê um valor: attribute mass : MassValue = 45 [kg];.
  3. Em uma definição que herda o atributo, redefina-o com um valor próprio: attribute redefines mass = 18 [kg];.
  4. Aponte para o valor. Um cartão de erro aparece se a unidade não combina com o tipo de grandeza.

Descrever o comportamento

  1. Escreva uma action def com seus parâmetros in e out.
  2. Adicione uma etapa por uso de action e ordene-as com first … then …; ou then.
  3. Use fork e join para etapas paralelas, decide e merge para alternativas.
  4. Adicione flow of Item from a.out to b.in; entre as etapas que passam itens.
  5. Na part que realiza o comportamento, escreva perform action name : Def; e, nas suas parts, perform name.step;.
  6. Abra a ação em uma Visão de fluxo de ações para vê-la desenhada (consulte Vistas SysML v2).

Escrever um requisito e rastreá-lo

  1. Escreva requirement <'ID'> name { doc /* The system shall … */ subject s : Def; }.
  2. Adicione require constraint { … } quando o requisito puder ser checado contra valores.
  3. Escreva satisfy name by somePart; onde o projeto o atende.
  4. Escreva uma verification cujo objetivo o verifique com verify.
  5. Abra Necessidades e requisitos → Requisitos: o requisito aparece com seu número, e Verificação → RVTM mostra como ele é verificado. Consulte Requisitos e verificação em projetos SysML v2.

Marcar um valor como TBD ou TBR

Escrever TBD no lugar de um valor não é SysML válido. Use os metadados do Holarch.

  1. Importe-os: private import HolarchMetadata::*;.
  2. Prefixe o atributo: #TBD attribute chargerPower : PowerValue; (ainda sem valor) ou #TBR attribute limit : TimeValue = 0.5 [h]; (um valor a revisar).
  3. Para registrar um responsável e um motivo, escreva a forma longa no corpo do atributo: @TBD { owner = "Powertrain lead"; rationale = "The charging standard is not chosen yet."; due = "2026-12-01"; }.

O registro de TBD/TBR lista esses valores. TBD e TBR especializam ModelingMetadata::StatusInfo, então outras ferramentas SysML v2 os leem como anotações de status. Inserir ▾ → Valor TBD e Valor TBR os escrevem para você.

Encontrar um nome da biblioteca

  1. Abra Biblioteca padrão nas ferramentas da barra lateral.
  2. Digite parte do nome em Buscar um package ou uma definição…, por exemplo MassValue.
  3. Clique em Copiar nome na linha. O nome qualificado, aqui ISQBase::MassValue, é copiado.
  4. Cole-o no Editor, ou importe o pacote e use o nome curto.

Exemplo prático: ler o requisito do sedã

Este exemplo acompanha um requisito pelo texto da demonstração Hybrid Car.

  1. Abra a demonstração e escolha VehicleRequirements na lista Packages do Editor.
  2. Encontre requirement def <'VR-1'> CurbMass. Seu require constraint { car.curbMass <= limit } compara a massa em ordem de marcha do sujeito com limit.
  3. Encontre requirement carSpec. Ele contém requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }. O uso redefine limit com a meta do nível do pacote maxCurbMass = 1650 [kg].
  4. Encontre satisfy carSpec by fleet.sedan;. Clique com ⌘ / Ctrl em sedan: o Editor abre Vehicles em part sedan : Car, onde attribute redefines curbMass = 1580 [kg]; dá o valor.
  5. De volta a VehicleRequirements, encontre verification def CurbMassTest. Seu objetivo verify carSpec.sedanMass; faz dele um caso de verificação do VR-1.1, e verification sedanWeighing : CurbMassTest { subject car = fleet.sedan; } o aplica ao sedã.
  6. Mude 1580 [kg] para 1700 [kg] em Vehicles e faça uma pausa. O sedã agora excede o limite de 1650 kg, e o Editor mostra em VehicleRequirements um aviso de que o requisito não é atendido por sedan, com a restrição falsa e seus valores. Desfaça com ⌘Z / Ctrl+Z.

Dicas e erros comuns

  • “…” is not defined here. (“…” não está definido aqui.) O nome está escrito errado ou seu pacote não está importado. Adicione private import Package::*; ou escreva o nome qualificado.
  • Um ; faltando. Cada declaração termina com ; ou com um corpo { … }. The declaration does not end. Add ; or a { … } body.
  • :> versus :>>. Use :> para especializar ou criar subconjunto; use :>> para substituir uma feature herdada. Redefinir uma feature que não é herdada gera “x” is not inherited by “y”.
  • Unidades precisam de imports. 5 [kg] só é resolvido onde SI está visível.
  • Dois membros com o mesmo nome. “x” is already used in this namespace. Renomeie um deles; uma variante redefine em vez disso.
  • verify fora de um objetivo. Coloque-o em objective { verify R; } de um caso de verificação.
  • Palavras-chave como nomes. Palavras como part, state ou action são reservadas. Coloque-as entre aspas ('state') ou escolha outro nome.

O que o Holarch suporta

O Holarch suporta as seguintes partes da notação textual SysML v2. O Editor checa todas elas, e o modelo as mantém.

ÁreaSuportado
Pacotes e namespacespackage, pacotes aninhados, library package (somente leitura), doc, comment … about, notas // e //* */, alias … for …, public/private/protected, nomes curtos <'1.2'>, nomes entre aspas
Importaçõesimports de membros e de namespace, ::*, recursivo ::**, imports filtrados [@Kind]
Definições e 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
Especialização:>/specializes, :/defined by, :>/subsets, :>>/redefines, conjugação ~, disjoint, cadeias de features a.b.c
Multiplicidades[n], [n..m], [*], [0..*], ordered, nonunique, expressões como limites
Valores e unidades=, :=, default, grandezas 5 [kg], expressões de unidade [m/s^2], os tipos de grandeza ISQ e as unidades SI e usuais dos EUA da biblioteca padrão, checagens de dimensão
Estruturaportas e portas conjugadas, connect, interfaces com extremidades, extremidades de conector nomeadas com multiplicidades, bind, flow of T from … to …, message
Açõesparâmetros, perform, sucessões (first … then …, then), fork, join, decide, merge, guardas, accept, send, assign, if, while, for, loop, start, done, terminate
Estadosentry/do/exit, transições com gatilho, guarda e efeito, estados parallel, estados aninhados, exhibit
Requisitossubject, actor, stakeholder, require constraint, assume constraint, frame concern, satisfy … by …, verify, nomes curtos como ids, doc como texto do requisito
Restrições e cálculosdefinições e usos de constraint e calc, return, assert constraint, chamadas, expressões KerML com aritmética, comparação, lógica, if ? else e operações de sequência, avaliação com unidades
Casos de uso, análise e verificaçãosubject, actor, objective, include use case, casos de análise com um resultado return, casos de verificação com verify e um veredito
Visõesview, view def, expose (com ::*, ::** e filtros), filter, viewpoint, frame, render, as definições de visão padrão
Alocação e rastrosallocate a to b, definições de alocação, dependency from … to …
Indivíduosdefinições e usos individual, snapshot e timeslice (também depois de then), seus valores e sucessões
Variabilidadedefinições e usos variation, membros variant e referências de variante (variant x;), escolhas por valor, configurações marcadas com @HolarchConfiguration (HolarchVariability)
Metadados@Name { … }, o prefixo #Name, metadata Name about …, os pacotes HolarchMetadata (TBD, TBR) e HolarchFrameworks do Holarch; metadata def definidas pelo usuário; palavras-chave definidas pelo usuário e metadados semânticos (#fault def …)

Mantido como escrito, não interpretado

O Holarch lê e mantém estas construções exatamente como escritas, mas não lhes dá significado próprio:

  • representações textuais em linguagens que não sejam SysML e KerML (mantidas como texto; consulte Representações textuais).

Ainda não disponível

  • Importar arquivos KerML (.kerml).
  • Commits em main, tags e merges pela Systems Modeling API: outras ferramentas fazem commit em branches de solicitações de mudança, que um aprovador aplica no Holarch (consulte A API e o MCP em projetos SysML v2).
  • Extensões da linguagem além de palavras-chave definidas pelo usuário e metadados semânticos.

Checagens

O Holarch checa o texto enquanto você digita. Cada problema é marcado na margem do Editor e sublinhado; a mensagem informa o problema e, em seguida, a correção. Erros impedem que um membro seja aplicado; avisos não.

ÁreaO que é checadoExemplo de mensagem
SintaxeCaracteres, comentários, strings, chaves, ;, nomes e tokens esperadosThis brace has no partner. Add the matching { or }, or delete this one.
NomesNomes não resolvidos, ambíguos, inválidos, duplicados (aviso) e privados“Batery” is not defined here. Check the spelling, or import its package.
Tipagem e especializaçãoCiclos; tipagem e especialização por uma definição do tipo certo; subconjunto e redefinição de features; redefinição apenas de features herdadas“capacity” is not inherited by “Car”. Specialize its type, or subset it with :> instead.
MultiplicidadesLimites válidos e inteiros; uma redefinição não mais ampla do que o que ela redefineMultiplicity [3..1] is not valid. Use a lower bound from 0 up to the upper bound.
Unidades e valoresDimensões compatíveis, unidades ausentes, nomes de unidades, tipos numéricosThe units do not match: kg and s. Convert one side to a compatible unit.
ExpressõesSintaxe, tipos de operandos, argumentos de cálculos, condições booleanasThe condition must be true or false; it is a number. Write a comparison such as x > 0.
EstruturaAs extremidades de conexões são features, interfaces conectam portas, direções de portas, fluxos e mensagens, tipos de itens de fluxo, tipos de vinculaçãoThese port directions do not fit together. Conjugate one port (~) or change a direction.
AçõesSucessões entre ações do mesmo corpo, quantidade de entradas e saídas dos nós de controle, guardas de decisão e else, start e done, atribuições, alvos de perform, os valores que um laço for percorre em relação ao tipo da variável do laçothen needs an earlier action. Add an action or first … then ….
EstadosTransições entre estados do mesmo corpo, um entry/do/exit de cada, transições iniciais, regiões paralelas, alvos de exhibit, o efeito do de uma transição (send para algo que possa receber, assign, accept, action ou uma ação nomeada), a carga de um gatilho em relação aos itens da sua porta, um gatilho sobre um valor simples da biblioteca como Real (aviso), gatilhos at que nomeiam um horário“electric” has substates but no initial transition, so none of them is entered. Add entry; then <first state>;.
Requisitos, casos e visõesMembros no lugar certo, um único sujeito, alvos de satisfy/verify/require, tipos de sujeito, alvos de expose e import, alvos de frameverify belongs in the objective of a verification case. Move it into objective { … }.
Representações textuaisCorpos SysML e KerML são analisados e declaram o elemento que representam; linguagens desconhecidas são apontadasThe representation of “SpeedLimit” declares a part definition, not a constraint definition. Make the body declare “SpeedLimit” itself.
Indivíduos, snapshots e fatias de tempoindividual apenas em ocorrências e com exatamente uma definição de indivíduo; snapshot/timeslice apenas em usos de ocorrência dentro de uma ocorrência; um time slice dentro de um snapshot (aviso)“parked” is individual, but none of its definitions is. Type it by an individual definition, or remove individual.
VariabilidadeUma variação possui apenas variantes; uma variante fica em uma variação e é do mesmo tipo; uma escolha é uma variante do seu ponto; abstract em uma variação é redundante (nota); os pontos em aberto de uma configuração (nota)“compact” is not a variant of “pack”. Choose one of: standardPack, largePack.
Palavras-chave definidas pelo usuário#Name nomeia uma definição de metadados; uma declaração sem palavra-chave da linguagem usa metadados semânticos (aviso); os metadados marcam apenas os tipos que seu annotatedElement permite; um tipo base semântico é uma definição ou um uso, combina com o elemento que marca (aviso) e não cria ciclo“safetyCritical” applies to PartDefinition, not to “invert” (ActionUsage). Move it, or remove it.
Valores de metadadosToda feature obrigatória de uma definição de metadados definida pelo usuário recebe um valor (aviso); cada valor e padrão cabe no tipo da sua feature (Boolean, String, números inteiros, enumerações); as restrições da definição valem para os valores dados; um corpo de metadados apenas redefine as features da definição; definições de metadados abstratas não são aplicadas; metadados semânticos escritos com about (aviso)The values of “SafetyRating” break its constraint levelRange: level >= 1 and level <= 4. Change the values.
AvaliaçãoRestrições, requisitos e objetivos que não valem para os valores atuais“sedanMass” is not met by “sedan”: … is false (…). Change the design values or the requirement.

A Biblioteca padrão

A página Biblioteca padrão lista os pacotes e definições que todo projeto SysML v2 pode usar: valores e unidades, grandezas, parts, portas, ações, estados, requisitos, análise e mais. Ela é somente leitura.

  • Abra-a em Ajustes → Biblioteca padrão nas ferramentas da barra lateral. Projetos LML não a têm.
  • Pastas. O lado esquerdo lista os arquivos da biblioteca por pasta: Bibliotecas do kernel, Biblioteca de sistemas, Bibliotecas de domínio (Analysis, Cause and Effect, Geometry, Metadata, Quantities and Units, Requirement Derivation) e Holarch (o pacote HolarchMetadata com TBD e TBR, HolarchVariability com HolarchConfiguration e HolarchRequirements com Objective).
  • Um arquivo. Selecione um arquivo para ver seus pacotes, cada um com sua documentação e uma tabela de suas definições: Nome, Tipo e Documentação.
  • Buscar. Digite em Buscar um package ou uma definição… para pesquisar os nomes e a documentação de todos os arquivos. Os resultados mostram o arquivo; clique nele para abri-lo. Pressione Esc para limpar.
  • Copiar nome copia o nome qualificado de um elemento, como ISQ::MassValue, para usar no Editor.
  • Mostrar texto mostra o arquivo da biblioteca como escrito; Mostrar definições volta para as tabelas.

A biblioteca é a biblioteca da versão de lançamento do SysML v2, com uma correção: uma tonne (alias 'metric ton') é convertida em 1000 kg; o arquivo da versão diz 0.001 kg. Seu modelo se refere a ela pelo nome; ela não é copiada para o projeto e não faz parte de uma exportação .sysml.

Limites

  • Um documento de texto maior que 8 MB não é checado: This text is larger than 8 MB and is not checked. Split it into several packages.
  • Uma linha com mais de 64 KB não é checada.
  • Aninhamentos com mais de 256 níveis não são checados.
  • A biblioteca padrão não pode ser editada.

SysML® e OMG® são marcas registradas da Object Management Group, Inc. nos Estados Unidos e em outros países.