Holarch

SysML v2

Notazione testuale SysML v2

Il linguaggio SysML v2 così come Holarch lo supporta, con esempi tratti dalla demo Hybrid Car, i controlli che esegue e la Libreria standard di sola lettura.

Come usarlo →

In questa pagina
  1. Panoramica
  2. Concetti
    1. Elementi, proprietari e nomi qualificati
    2. Package
    3. Import e visibilità
    4. Definizioni e usi
    5. Tipizzazione, specializzazione e ridefinizione
    6. Molteplicità
    7. Valori e unità
    8. Struttura: porte, connessioni, interfacce, binding e flussi
    9. Comportamento: azioni
    10. Comportamento: stati
    11. Requisiti, vincoli e verifica
    12. Casi d’uso
    13. Viste
    14. Commenti, documentazione e metadati
    15. Individui, snapshot e time slice
    16. Variazioni, varianti e configurazioni
    17. Rappresentazioni testuali
  3. Come usarlo
    1. Modellare una struttura
    2. Assegnare valori con unità
    3. Descrivere il comportamento
    4. Scrivere un requisito e tracciarlo
    5. Contrassegnare un valore come TBD o TBR
    6. Trovare un nome della libreria
  4. Esempio guidato: leggere il requisito della berlina
  5. Suggerimenti ed errori comuni
  6. Che cosa supporta Holarch
    1. Conservati come scritti, non interpretati
    2. Non ancora disponibile
  7. Controlli
  8. La Libreria standard
  9. Limiti
  10. Pagine correlate

Panoramica

SysML v2 descrive un sistema come un albero di elementi con nome, scritto come testo. Holarch supporta la notazione testuale SysML v2, basata sulla specifica OMG SysML v2. Il testo si scrive nell'Editor, e Holarch mostra gli stessi elementi nel Browser, nelle viste, nelle tabelle e nelle pagine del ciclo di vita.

Questa pagina insegna la notazione con esempi tratti dalla demo Hybrid Car (SysML v2). Elenca poi ciò che Holarch supporta, i controlli che esegue sul testo e la Libreria standard.

Concetti

Elementi, proprietari e nomi qualificati

Ogni elemento ha un proprietario, tranne i package di primo livello. Il nome qualificato di un elemento è la catena dei nomi dei suoi proprietari, uniti da ::. Nella demo, la batteria della definizione del gruppo propulsore è Vehicles::Powertrain::battery.

Un nome con spazi o altri caratteri speciali va tra virgolette singole: 'Fuel Tank'. Un nome breve tra parentesi angolari dà a un elemento un secondo identificatore breve: requirement def <'VR-1'> CurbMass. Holarch usa il nome breve di un requisito come suo numero.

Package

Un package raggruppa elementi, come una cartella. I package possono essere annidati. Ogni package di primo livello è un documento nell'Editor.

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

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

Import e visibilità

Un import rende visibili i membri di un altro package con i loro nomi brevi.

  • import ISQ::*; importa i membri di ISQ.
  • import VehicleRequirements::**; importa anche i membri degli elementi annidati (ricorsivo).
  • import Vehicles::Car; importa un solo elemento.
  • import Vehicles::*[@SysML::PartDefinition]; importa solo i membri di un tipo (un import filtrato).

private, protected e public stabiliscono chi altro vede un membro o un import. La demo scrive private import in modo che gli import non passino ai package che a loro volta la importano.

Senza un import, scrivere il nome qualificato: ISQ::MassValue si risolve ovunque, MassValue solo dove ISQ è importato.

Un alias dà a un elemento un secondo nome: alias Hybrid for Car;.

Definizioni e usi

Una definizione descrive un tipo di cosa. Un uso è un singolo utilizzo di una definizione all'interno di un altro elemento. La maggior parte delle parole chiave esiste in entrambe le forme:

DefinizioneUsoChe cosa rappresenta
part def Battery;part battery : Battery;Un sistema, sottosistema o componente
attribute def TirePressure;attribute mass : MassValue = 45 [kg];Un valore, spesso con unità
item def Fuel;item fuel : Fuel;Qualcosa che fluisce o viene gestito
port def FuelPort { … }port fuelOut : FuelPort;Un punto di connessione su una parte
connection def … / interface def FuelLine { … }interface fuel : FuelLine connect …;Un collegamento tra parti o porte
action def ProduceTorque { … }action produce : ProduceTorque;Comportamento: un passo che riceve input e fornisce output
state def PowertrainStates { … }state off;Comportamento: uno stato e le sue transizioni
constraint def MassLimit { … }constraint …;Una condizione booleana sui valori
calc def PowerToWeight { … }calc …;Un calcolo con un valore return
requirement def <'VR-1'> CurbMass { … }requirement <'VR-1.1'> sedanMass : CurbMass;Un requisito
use case def DriveToWork { … }use case commute : DriveToWork;Un caso d'uso
analysis def PowerToWeightAnalysis { … }analysis sedanPowerToWeight : …;Un caso di analisi
verification def CurbMassTest { … }verification sedanWeighing : CurbMassTest;Un caso di verifica
view def RequirementsView { … }view driveCycleFlow : ActionFlowView { … }Una vista del modello
enum def DriveMode { … }attribute mode : DriveMode;Un insieme fisso di valori

I membri annidati in una definizione appartengono a ogni suo uso. part frontAxle : Axle; ha differential, leftWheel e rightWheel di Axle senza ripeterli.

Tipizzazione, specializzazione e ridefinizione

Quattro operatori mettono in relazione definizioni e usi. Ognuno ha anche una forma a parola chiave.

OperatoreParola chiaveSignificatoEsempio
:defined byTipizza un uso con una definizionepart engine : Engine;
:> su una definizionespecializesLa definizione è un tipo dell'altra e ne eredita i membripart def FuelTank :> Component
:> su un usosubsetsL'uso è un sottoinsieme di un altro usopart spareWheel :> wheels;
:>>redefinesSostituisce un uso ereditato, per esempio per assegnargli un valoreattribute redefines mass = 18 [kg];
~Coniuga una porta: le sue feature in e out si scambianoport fuelIn : ~FuelPort;

La ridefinizione è il modo in cui una variante o una parte configurata cambia ciò che eredita. Nella demo, SportCar elimina con una ridefinizione la ruota di scorta:

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

abstract contrassegna una definizione senza istanze dirette (abstract part def Component). ref contrassegna un riferimento non posseduto. in, out e inout impostano la direzione di una feature o di un parametro. end contrassegna le estremità di una definizione di connessione o di interfaccia.

Molteplicità

Una molteplicità tra parentesi quadre indica quanti ce ne sono.

  • [2]: esattamente due. part runabout : CityCar [2];
  • [0..1]: facoltativo. part spare : Wheel [0..1];
  • [1..*] e [*]: uno o più, un numero qualsiasi.
  • [0]: nessuno, usato per rimuovere una parte ereditata.
  • I limiti possono essere espressioni. ordered e nonunique seguono le parentesi.

Valori e unità

= vincola un valore. := dà un valore iniziale che può cambiare. default dà un valore predefinito che una ridefinizione può sostituire.

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

Una grandezza è un numero con un'unità tra parentesi quadre. Le unità si combinano con *, / e ^ ([m/s^2]). I tipi di grandezza come MassValue provengono da ISQ, e le unità come kg da SI (o USCustomaryUnits). Holarch controlla le dimensioni: assegnare 5 [s] a un MassValue è un errore.

Le espressioni usano l'aritmetica, il confronto (<=, ==), gli operatori logici (and, or, not, implies), il condizionale if c ? a else b, le catene di feature (car.powertrain.battery.capacity), le chiamate di calcoli (PowerToWeight(power, mass)) e le operazioni su sequenze come ->sum, ->size, ->select e ->collect. Holarch le valuta con le unità per valori, vincoli, viste e pagine di analisi.

Struttura: porte, connessioni, interfacce, binding e flussi

Le parti si collegano tramite le loro porte.

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; unisce due parti o porte.
  • Un'interfaccia è una connessione tipizzata tra porte. La sua definizione nomina le estremità: interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  • Ogni estremità di una connessione o di un'interfaccia può avere un nome e una molteplicità: interface motorShaft : Shaft connect [1] driver ::> motor.output to [1] driven ::> transmission.motorIn;. Un'estremità con nome è una feature della connessione, quindi motorShaft.driver vi fa riferimento.
  • bind a = b; indica che due feature sono la stessa (un binding connector).
  • flow of Fuel from supply.fuel to produce.fuel; trasporta un item da una feature a un'altra. message invia un item tra parti come evento.

Comportamento: azioni

Una definizione di azione contiene i suoi passi (usi di azione), i suoi parametri e l'ordine dei passi.

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;
}
  • Le successioni ordinano i passi: first a then b;, oppure then b; subito dopo a. start e done sono l'inizio e la fine.
  • Nodi di controllo: fork e join per percorsi paralleli; decide e merge per alternative. Una successione con guardia dopo una decisione si scrive if speed > 30 then cruise;, e else brake; è il ramo predefinito.
  • Terminazione: terminate; termina subito l'azione che lo contiene, con tutti i suoi passi ancora in esecuzione; then terminate; lo colloca dopo il passo precedente. terminate x; termina l'occorrenza x.
  • Altre azioni: accept attende un segnale, send ne invia uno, assign x := expr; cambia un valore, if esegue un blocco o lo salta, while … { … } until …; e for v in seq { … } ripetono un blocco.
  • Allocazione del comportamento: una parte esegue (perform) un'azione (perform action trip : DriveCycle;, perform trip.supply;), e allocate a to b; alloca un elemento a un altro.

Comportamento: stati

Una definizione di stato contiene gli stati e le transizioni tra di essi.

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; imposta lo stato iniziale.
  • Le transizioni hanno un trigger (accept StartRequest), una guardia facoltativa (if charge > 20) e un effetto facoltativo (do …). La forma breve segue lo stato di origine; la forma lunga è transition name first a … then b;.
  • Nel modello, il trigger e l'effetto di una transizione sono elementi a sé: un'azione accept e un'azione (send, assign, perform, terminate o un'azione con nome). Il Browser li mostra come trigger ed effect sotto la transizione. Sono l'accepter e l'effect propri della transizione, quindi altre parti del modello possono nominarli: chargerStates.plugIn.effect.sentMessage è il messaggio inviato dall'effetto, così come lo vincola un modello di sequenza.
  • Un trigger tramite una porta deve accettare qualcosa che la porta trasporta: nel ChargeManager della demo, accept connectCharger : ChargerConnected via chargePort corrisponde a in connected : ChargerConnected della porta. L'effetto send new ChargeRequest() to controller invia a una parte; un valore come un attributo non può ricevere un messaggio.
  • Le azioni entry, do ed exit vengono eseguite all'ingresso, durante la permanenza e all'uscita dallo stato. Gli stati parallel hanno regioni tutte attive contemporaneamente.
  • Una parte esibisce (exhibit) uno stato: exhibit state powertrainStates : PowertrainStates;.

Requisiti, vincoli e verifica

Un requisito contiene il suo enunciato in doc, l'elemento a cui si applica come subject e una condizione verificabile come 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 indica una condizione che il requisito presuppone. Quando non è soddisfatta, quel requisito e i requisiti annidati in esso contano come rispettati; il requisito che lo contiene e gli altri requisiti annidati vengono comunque controllati. actor, stakeholder e frame concern indicano per chi e per che cosa è il requisito.
  • satisfy R by part; indica che una parte rispetta un requisito.
  • Un caso di verifica verifica i requisiti nel suo obiettivo: objective { verify carSpec.sedanMass; }. Può restituire return verdict : Boolean = …;.
  • Un caso di analisi ha un soggetto, un obiettivo e un risultato return che Holarch valuta quando ogni input ha un valore. Gli attributi del caso senza valore vengono risolti dalle equazioni == del suo obiettivo (Casi di analisi con incognite).
  • connection : Derivation connect original to derived; registra un requisito derivato. #refinement dependency x to R; registra un raffinamento.
  • dependency from a to b; registra una traccia generica.

Casi d’uso

use case def DriveToWork { subject car : Car; actor driver : Driver; objective { … } include use case startCar : StartCar; }. Un uso di caso d'uso riprende il soggetto e gli attori della sua definizione.

Viste

Una vista mostra una parte del modello. È tipizzata da una definizione di vista standard ed espone (expose) ciò che mostra:

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

filter restringe gli elementi (filter @SysML::RequirementUsage;). render sceglie una rappresentazione grafica. Un viewpoint inquadra le esigenze che una vista deve affrontare. Viste SysML v2 spiega ogni tipo di vista.

Commenti, documentazione e metadati

  • doc /* text */ documenta il suo proprietario. Fa parte del modello; per un requisito è il testo del requisito.
  • comment about x /* text */ è una nota nel modello su un altro elemento.
  • // text e //* text */ sono note solo nel testo. Holarch le conserva nel testo, ma non sono elementi del modello.
  • I metadati annotano un elemento: @TBD { owner = "Powertrain lead"; } in un corpo, #TBR attribute limit … come prefisso, oppure metadata Capability about Vehicles::Car; dall'esterno.
  • Parole chiave definite dall'utente: qualsiasi definizione di metadati funziona come parola chiave: #safetyCritical part controller : Controller; contrassegna il controller con i metadati SafetyCritical (nome breve <safetyCritical>). Una definizione di metadati può limitare ciò che contrassegna: :>> annotatedElement : SysML::PartDefinition; consente solo definizioni di parte.
  • Metadati semantici: una definizione di metadati che specializza SemanticMetadata imposta un tipo base, :>> baseType = faults meta SysML::Usage;. Ogni elemento che contrassegna specializza quindi la base: un uso fa da subset di un uso base, una definizione specializza una definizione base o le definizioni di un uso base. Così #fault def BatteryOverheat; e #fault overheat : BatteryOverheat; sono guasti e hanno le feature di Fault. Con i metadati semantici la parola chiave del linguaggio si può omettere, come in queste due righe; il Browser li mostra con la loro parola chiave (#fault def). Scritto dall'esterno, metadata Fault about x; non rende x un guasto: il controllo avvisa e suggerisce di contrassegnare x stesso con #fault.
  • Metadati con un significato proprio: le feature di una definizione di metadati sono ciò che ogni suo uso deve indicare, e i suoi vincoli devono valere per esse. Con metadata def SafetyRating { attribute level : Natural; assert constraint { level >= 1 and level <= 4 } }, il controllo segnala @SafetyRating; (nessun livello) e @SafetyRating { level = 7; } (fuori intervallo); @SafetyRating { level = 4; } va bene. Una feature con un valore o un default nella definizione, o dichiarata [0..1], si può omettere. Ogni valore deve adattarsi al tipo della sua feature: true o false per un Boolean, testo tra virgolette per una String, un numero intero per un Integer (0 o più per un Natural, maggiore di 0 per un Positive) e, per un'enumerazione, uno dei suoi valori, come HazardAnalysis::fmea; il controllo segnala qualsiasi altro valore, e un valore predefinito nella definizione che non si adatta. Un corpo di metadati assegna solo valori alle feature della definizione (level = 4;), e un abstract metadata def non può essere applicato. La demo Hybrid Car classifica il suo controller con @SafetyRating { level = 4; } e registra la revisione della batteria come @SafetyReview { method = HazardAnalysis::fmea; closed = true; }. Nell'Editor, Inserisci ▾ → Definizione di metadati inizia una definizione con una feature e una regola, e Applica metadati ne applica una all'interno di un corpo. Senza scrivere testo: selezionare una definizione o un uso e usare la sezione Metadati dell'ispettore. Aggiungi metadati applica una delle definizioni di metadati del progetto; ogni feature ha poi un campo (un elenco dei valori per un'enumerazione o un Boolean, testo semplice per una String, che Holarch scrive tra virgolette; il valore predefinito della definizione compare come suggerimento, e una feature senza di esso è contrassegnata come Obbligatorio); i rilievi del controllo per quei metadati compaiono sotto di esso; Rimuovi li toglie. Ogni modifica si può annullare con un solo annullamento. I metadati della libreria standard e quelli di Holarch (simulazione, obiettivi, variabilità) mantengono i propri controlli e non sono elencati lì.

Individui, snapshot e time slice

Un individuo è una cosa particolare per tutta la sua vita, come un'auto con il suo numero di serie, anziché un tipo di cosa. Uno snapshot è quella cosa in un istante; un time slice è un periodo della sua vita. Entrambi appartengono all'occorrenza che li possiede e ne hanno le feature, quindi possono dare a quelle feature valori propri.

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 precede la parola chiave del tipo (individual part def, individual item def) oppure sta da solo (individual def Plate_77;). Un uso scritto individual è tipizzato da esattamente una definizione individuale: individual car1 : Car_VIN1234;.
  • snapshot e timeslice precedono una parola chiave di tipo o stanno da soli, all'interno di una parte, un item, un'azione o un'altra occorrenza. then timeslice secondOwner; ordina un time slice dopo il membro che lo precede.
  • Un valore all'interno di uno snapshot o di un time slice viene letto prima lì, poi dall'individuo, poi dalla sua definizione. Nell'esempio, atService.mileage è 15.000 km e il vincolo è soddisfatto.
  • Solo le occorrenze possono essere individui, snapshot o time slice: attributi ed enumerazioni sono valori.
  • In Architettura → Parti e nelle viste Database e Griglia, la colonna Istanze elenca gli individui della definizione di ogni parte (per part sedan : Car: Car_VIN1234): le definizioni individuali che la specializzano e gli usi individuali che essa tipizza. Anche Individuale (Sì) e Porzione (Istantanea o Time slice) sono colonne (Colonne ▾ → SysML v2). Parti mostra Istanze per impostazione predefinita quando il modello ha un individuo, e l'esportazione Tabella (CSV) include allora le tre colonne; l'esportazione Definizioni le elenca per ogni elemento che le possiede.
  • Nell'ispettore, Occorrenza sotto Feature imposta Individuale e, per gli usi, Intera vita, Time slice o Istantanea. Il filtro per tipo del Browser ha Individui, e il menu ⋯ di una riga ha Nuovo snapshot… e Nuovo time slice…. La Vista generale mostra «individual part def», «snapshot» e «timeslice» nelle intestazioni dei riquadri, elenca gli snapshot e i time slice di un riquadro in un comparto proprio e disegna le successioni tra riquadri come frecce tratteggiate; Disponi ▾ → Disponi come cronologia li allinea da sinistra a destra. Nella demo Hybrid Car, la Vista generale carLifeline mostra gli snapshot e il time slice di Car_VIN1234.

Variazioni, varianti e configurazioni

Una variazione elenca le scelte consentite in un punto di un progetto; ogni scelta è una variante. Una definizione di variazione (variation part def) è un insieme riutilizzabile di scelte; un uso di variazione (variation part charger) è un punto all'interno di un progetto. Una configurazione sceglie una variante per ogni 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 ha le feature della sua variazione e può ridefinirle: largePack ha una capacity perché BatteryPack è una Battery.
  • variant x; senza parola chiave di tipo rende l'uso esistente x una delle scelte; prende il nome da x.
  • Una variazione possiede solo varianti (e definizioni, commenti, metadati e import). Una variazione è già astratta, quindi abstract su di essa viene segnalato come ridondante.
  • Scegliere una variante con un valore: part :>> pack = BatteryPack::largePack;. Una scelta che non è una variante di quel punto è un errore.
  • Finché un punto non ha una scelta, il suo valore è sconosciuto, quindi un'asserzione su di esso non è né rispettata né violata. In una configurazione si usano i valori delle varianti scelte.
  • Contrassegnare una configurazione con @HolarchConfiguration (package HolarchVariability, nella Libreria standard sotto Holarch): l'Editor segnala quindi ogni punto non ancora scelto.
  • Nell'Editor, Inserisci ▾ scrive ciascuno di questi: Variazione (una definizione a livello di package, un punto all'interno di una parte), Variante (all'interno di una variazione), Configurazione e Scelta della variante (all'interno di una configurazione).
  • Nella demo Hybrid Car, CarLine ha due punti (pack e charger), e selfChargingHybrid e plugInHybrid ne sono configurazioni; l'asserzione esclude una wallbox con il pacco standard.

Rappresentazioni testuali

Una rappresentazione testuale scrive un elemento in un altro linguaggio: rep language "Python" /* … */ all'interno del corpo dell'elemento. Il corpo viene conservato come testo. Il modello è ciò che dichiara il SysML che lo circonda; Holarch non esegue mai un corpo.

  • Nella demo Hybrid Car, DriveWheels riporta il suo calcolo in Python: rep language "Python" /* wheel_speed = torque.value * GEAR_RATIOS[gear] / WHEEL_RADIUS */.
  • Un corpo in "sysml" o "kerml" viene controllato. SpeedLimit è scritto come rep language "sysml" /* speed <= limit */, e Holarch lo valuta come un vincolo scritto direttamente.
  • L'Editor evidenzia i corpi SysML e KerML come codice su uno sfondo colorato. Gli altri linguaggi compaiono come testo di commento.
  • La sezione Rappresentazione dell'ispettore elenca ogni rappresentazione con il suo Linguaggio e il corpo. Fare clic su Aggiungi rappresentazione su una definizione o un uso per aggiungerne una, e su Rimuovi per eliminarla.
  • La vista Action Flow contrassegna un'azione la cui definizione ha una rappresentazione con il suo linguaggio tra parentesi graffe, come {Python}.
  • Linguaggi noti: SysML, KerML, OCL, Alf, Python, JavaScript, MATLAB, Modelica, C, linguaggio naturale (naturalLanguage, English, text). Una versione dopo il nome viene ignorata (OCL2.0, Python 3).
  • Un corpo non può contenere */, che chiuderebbe il commento.

I commenti di discussione, le etichette, gli assegnatari e le scadenze propri di Holarch sono conservati accanto al modello. Non vengono scritti nel testo.

Come usarlo

Modellare una struttura

  1. Nell'Editor, aprire un package (o fare clic su + Nuovo package).
  2. Scrivere un port def per ogni tipo di punto di connessione, con feature direzionate (out attribute torque : TorqueValue;).
  3. Scrivere un part def per ogni tipo di componente, con i suoi attributi e le sue porte.
  4. Scrivere un part def per l'assieme, con una part per ogni componente.
  5. Collegare le parti: connect a.p to b.q;, oppure interface name : Def connect a.p to b.q;.
  6. Fare una pausa. La riga di stato riporta Applicato e il Browser mostra i nuovi elementi.

Inserisci ▾ (o ⌃⇧Space / Ctrl+Shift+Space) scrive ciascuno di questi costrutti, con campi da compilare. Vedere Inserire un costrutto.

Assegnare valori con unità

  1. Importare i tipi di grandezza e le unità all'inizio del package: private import ISQ::*; e private import SI::*;.
  2. Tipizzare l'attributo con un tipo di grandezza e assegnare un valore: attribute mass : MassValue = 45 [kg];.
  3. In una definizione che eredita l'attributo, ridefinirlo con un valore proprio: attribute redefines mass = 18 [kg];.
  4. Puntare il valore. Se l'unità non è adatta al tipo di grandezza compare una scheda di errore.

Descrivere il comportamento

  1. Scrivere un action def con i suoi parametri in e out.
  2. Aggiungere un passo per ogni uso di action e ordinarli con first … then …; o then.
  3. Usare fork e join per i passi paralleli, decide e merge per le alternative.
  4. Aggiungere flow of Item from a.out to b.in; tra i passi che si scambiano item.
  5. Nella parte che svolge il comportamento, scrivere perform action name : Def; e, nelle sue parti, perform name.step;.
  6. Aprire l'azione in una Action Flow View per vederla disegnata (vedere Viste SysML v2).

Scrivere un requisito e tracciarlo

  1. Scrivere requirement <'ID'> name { doc /* The system shall … */ subject s : Def; }.
  2. Aggiungere require constraint { … } quando il requisito si può controllare rispetto a dei valori.
  3. Scrivere satisfy name by somePart; dove il progetto lo rispetta.
  4. Scrivere una verification il cui obiettivo lo verifica con verify.
  5. Aprire Esigenze e requisiti → Requisiti: il requisito è elencato con il suo numero, e Verifica → RVTM mostra come viene verificato. Vedere Requisiti e verifica nei progetti SysML v2.

Contrassegnare un valore come TBD o TBR

Scrivere TBD al posto di un valore non è SysML valido. Usare invece i metadati di Holarch.

  1. Importarli: private import HolarchMetadata::*;.
  2. Aggiungere un prefisso all'attributo: #TBD attribute chargerPower : PowerValue; (ancora nessun valore) o #TBR attribute limit : TimeValue = 0.5 [h]; (un valore da rivedere).
  3. Per registrare un responsabile e una motivazione, scrivere la forma lunga nel corpo dell'attributo: @TBD { owner = "Powertrain lead"; rationale = "The charging standard is not chosen yet."; due = "2026-12-01"; }.

Il registro TBD/TBR elenca questi valori. TBD e TBR specializzano ModelingMetadata::StatusInfo, quindi altri strumenti SysML v2 li leggono come annotazioni di stato. Inserisci ▾ → Valore TBD e Valore TBR li scrivono automaticamente.

Trovare un nome della libreria

  1. Aprire la Libreria standard dagli strumenti della barra.
  2. Digitare parte del nome in Trova un package o una definizione…, per esempio MassValue.
  3. Fare clic su Copia nome nella riga. Il nome qualificato, qui ISQBase::MassValue, viene copiato.
  4. Incollarlo nell'Editor, oppure importarne il package e usare il nome breve.

Esempio guidato: leggere il requisito della berlina

Questo esempio segue un requisito attraverso il testo della demo Hybrid Car.

  1. Aprire la demo e scegliere VehicleRequirements nell'elenco Package dell'Editor.
  2. Trovare requirement def <'VR-1'> CurbMass. Il suo require constraint { car.curbMass <= limit } confronta la massa in ordine di marcia del soggetto con limit.
  3. Trovare requirement carSpec. Contiene requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }. L'uso ridefinisce limit con l'obiettivo a livello di package maxCurbMass = 1650 [kg].
  4. Trovare satisfy carSpec by fleet.sedan;. Fare ⌘ / Ctrl-clic su sedan: l'Editor apre Vehicles su part sedan : Car, dove attribute redefines curbMass = 1580 [kg]; fornisce il valore.
  5. Tornati in VehicleRequirements, trovare verification def CurbMassTest. Il suo obiettivo verify carSpec.sedanMass; lo rende un caso di verifica di VR-1.1, e verification sedanWeighing : CurbMassTest { subject car = fleet.sedan; } lo applica alla berlina.
  6. Cambiare 1580 [kg] in 1700 [kg] in Vehicles e fare una pausa. La berlina ora supera il limite di 1650 kg, e l'Editor mostra in VehicleRequirements un avviso che il requisito non è rispettato da sedan, con il vincolo falso e i suoi valori. Annullare con ⌘Z / Ctrl+Z.

Suggerimenti ed errori comuni

  • “…” is not defined here. (non è definito qui) Il nome è scritto male oppure il suo package non è importato. Aggiungere private import Package::*;, oppure scrivere il nome qualificato.
  • Un ; mancante. Ogni dichiarazione termina con ; o con un corpo { … }. The declaration does not end. Add ; or a { … } body.
  • :> rispetto a :>>. Usare :> per specializzare o fare subset; usare :>> per sostituire una feature ereditata. Ridefinire una feature non ereditata produce “x” is not inherited by “y”.
  • Le unità richiedono import. 5 [kg] si risolve solo dove SI è visibile.
  • Due membri con lo stesso nome. “x” is already used in this namespace. Rinominarne uno; una variante invece ridefinisce.
  • verify fuori da un obiettivo. Inserirlo in objective { verify R; } di un caso di verifica.
  • Parole chiave come nomi. Parole come part, state o action sono riservate. Metterle tra virgolette ('state') o scegliere un altro nome.

Che cosa supporta Holarch

Holarch supporta le seguenti parti della notazione testuale SysML v2. L'Editor le controlla tutte e il modello le conserva.

AreaSupportato
Package e namespacepackage, package annidati, library package (sola lettura), doc, comment … about, note // e //* */, alias … for …, public/private/protected, nomi brevi <'1.2'>, nomi tra virgolette
Importimport di membership e di namespace, ::*, ricorsivi ::**, import filtrati [@Kind]
Definizioni e usipart, 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
Specializzazione:>/specializes, :/defined by, :>/subsets, :>>/redefines, coniugazione ~, disjoint, catene di feature a.b.c
Molteplicità[n], [n..m], [*], [0..*], ordered, nonunique, espressioni come limiti
Valori e unità=, :=, default, grandezze 5 [kg], espressioni di unità [m/s^2], i tipi di grandezza ISQ e le unità SI e consuetudinarie statunitensi della libreria standard, controlli dimensionali
Strutturaporte e porte coniugate, connect, interfacce con estremità, estremità di connettore con nome e con molteplicità, bind, flow of T from … to …, message
Azioniparametri, perform, successioni (first … then …, then), fork, join, decide, merge, guardie, accept, send, assign, if, while, for, loop, start, done, terminate
Statientry/do/exit, transizioni con trigger, guardia ed effetto, stati parallel, stati annidati, exhibit
Requisitisubject, actor, stakeholder, require constraint, assume constraint, frame concern, satisfy … by …, verify, nomi brevi come id, doc come testo del requisito
Vincoli e calcolidefinizioni e usi di constraint e calc, return, assert constraint, chiamate, espressioni KerML con aritmetica, confronto, logica, if ? else e operazioni su sequenze, valutazione con unità
Casi d'uso, analisi e verificasubject, actor, objective, include use case, casi di analisi con un risultato return, casi di verifica con verify e un verdetto
Visteview, view def, expose (con ::*, ::** e filtri), filter, viewpoint, frame, render, le definizioni di vista standard
Allocazione e tracceallocate a to b, definizioni di allocazione, dependency from … to …
IndividuiDefinizioni e usi di individual, snapshot e timeslice (anche dopo then), i loro valori e le successioni
VariabilitàDefinizioni e usi di variation, membri variant e riferimenti a varianti (variant x;), scelte per valore, configurazioni contrassegnate con @HolarchConfiguration (HolarchVariability)
Metadati@Name { … }, il prefisso #Name, metadata Name about …, i package HolarchMetadata (TBD, TBR) e HolarchFrameworks di Holarch; metadata def definiti dall'utente; parole chiave definite dall'utente e metadati semantici (#fault def …)

Conservati come scritti, non interpretati

Holarch legge e conserva questi costrutti esattamente come scritti, ma non attribuisce loro un significato proprio:

Non ancora disponibile

  • Importazione di file KerML (.kerml).
  • Commit su main, tag e merge tramite la Systems Modeling API: gli altri strumenti eseguono commit nei rami delle richieste di modifica, che un approvatore applica in Holarch (vedere API e MCP nei progetti SysML v2).
  • Estensioni del linguaggio oltre alle parole chiave definite dall'utente e ai metadati semantici.

Controlli

Holarch controlla il testo durante la digitazione. Ogni problema è segnalato nel margine dell'Editor e sottolineato; il messaggio indica il problema, poi la correzione. Gli errori impediscono l'applicazione di un membro; gli avvisi no.

AreaCosa viene controllatoMessaggio di esempio
SintassiCaratteri, commenti, stringhe, parentesi graffe, ;, nomi e token attesiThis brace has no partner. Add the matching { or }, or delete this one.
NomiNomi non risolti, ambigui, non validi, duplicati (avviso) e privati“Batery” is not defined here. Check the spelling, or import its package.
Tipizzazione e specializzazioneCicli; tipizzazione e specializzazione con una definizione del tipo giusto; subsetting e ridefinizione di feature; ridefinizione solo di feature ereditate“capacity” is not inherited by “Car”. Specialize its type, or subset it with :> instead.
MolteplicitàLimiti validi e interi; una ridefinizione non più ampia di ciò che ridefinisceMultiplicity [3..1] is not valid. Use a lower bound from 0 up to the upper bound.
Unità e valoriDimensioni corrispondenti, unità mancanti, nomi di unità, tipi numericiThe units do not match: kg and s. Convert one side to a compatible unit.
EspressioniSintassi, tipi degli operandi, argomenti dei calcoli, condizioni booleaneThe condition must be true or false; it is a number. Write a comparison such as x > 0.
StrutturaLe estremità delle connessioni sono feature, le interfacce collegano porte, direzioni di porte, flussi e messaggi, tipi degli item dei flussi, tipi dei bindingThese port directions do not fit together. Conjugate one port (~) or change a direction.
AzioniSuccessioni tra azioni dello stesso corpo, numero di ingressi e uscite dei nodi di controllo, guardie delle decisioni ed else, start e done, assegnazioni, destinazioni di perform, i valori su cui itera un ciclo for rispetto al tipo della variabile del ciclothen needs an earlier action. Add an action or first … then ….
StatiTransizioni tra stati dello stesso corpo, un solo entry/do/exit ciascuno, transizioni iniziali, regioni parallele, destinazioni di exhibit, l'effetto do di una transizione (send verso qualcosa che può ricevere, assign, accept, action o un'azione con nome), il payload di un trigger rispetto agli item della sua porta, un trigger su un semplice valore della libreria come Real (avviso), trigger at che indicano un tempo“electric” has substates but no initial transition, so none of them is entered. Add entry; then <first state>;.
Requisiti, casi e visteMembri nella posizione corretta, un solo soggetto, destinazioni di satisfy/verify/require, tipi dei soggetti, destinazioni di expose e import, destinazioni di frameverify belongs in the objective of a verification case. Move it into objective { … }.
Rappresentazioni testualiI corpi SysML e KerML vengono analizzati e dichiarano l'elemento che rappresentano; i linguaggi sconosciuti vengono segnalatiThe representation of “SpeedLimit” declares a part definition, not a constraint definition. Make the body declare “SpeedLimit” itself.
Individui, snapshot e time sliceindividual solo sulle occorrenze e con esattamente una definizione individuale; snapshot/timeslice solo su usi di occorrenza all'interno di un'occorrenza; un time slice all'interno di uno snapshot (avviso)“parked” is individual, but none of its definitions is. Type it by an individual definition, or remove individual.
VariabilitàUna variazione possiede solo varianti; una variante si trova in una variazione ed è del suo tipo; una scelta è una variante del suo punto; abstract su una variazione è ridondante (nota); i punti aperti di una configurazione (nota)“compact” is not a variant of “pack”. Choose one of: standardPack, largePack.
Parole chiave definite dall'utente#Name indica una definizione di metadati; una dichiarazione senza parola chiave del linguaggio usa metadati semantici (avviso); i metadati contrassegnano solo i tipi consentiti dal loro annotatedElement; un tipo base semantico è una definizione o un uso, si adatta all'elemento che contrassegna (avviso) e non crea cicli“safetyCritical” applies to PartDefinition, not to “invert” (ActionUsage). Move it, or remove it.
Valori dei metadatiOgni feature obbligatoria di una definizione di metadati definita dall'utente riceve un valore (avviso); ogni valore e valore predefinito si adatta al tipo della sua feature (Boolean, String, numeri interi, enumerazioni); i vincoli della definizione valgono per i valori indicati; un corpo di metadati ridefinisce solo le feature della definizione; le definizioni di metadati astratte non vengono applicate; metadati semantici scritti con about (avviso)The values of “SafetyRating” break its constraint levelRange: level >= 1 and level <= 4. Change the values.
ValutazioneVincoli, requisiti e obiettivi che non sono soddisfatti con i valori correnti“sedanMass” is not met by “sedan”: … is false (…). Change the design values or the requirement.

La Libreria standard

La pagina Libreria standard elenca i package e le definizioni che ogni progetto SysML v2 può usare: valori e unità, grandezze, parti, porte, azioni, stati, requisiti, analisi e altro. È di sola lettura.

  • Aprirla da Impostazioni → Libreria standard negli strumenti della barra. I progetti LML non la hanno.
  • Cartelle. Il lato sinistro elenca i file della libreria per cartella: Kernel Libraries, Systems Library, Domain Libraries (Analysis, Cause and Effect, Geometry, Metadata, Quantities and Units, Requirement Derivation) e Holarch (il package HolarchMetadata con TBD e TBR, HolarchVariability con HolarchConfiguration, e HolarchRequirements con Objective).
  • Un file. Selezionare un file per vederne i package, ciascuno con la sua documentazione e una tabella delle sue definizioni: Nome, Tipo e Documentazione.
  • Trova. Digitare in Trova un package o una definizione… per cercare nei nomi e nella documentazione di ogni file. I risultati mostrano il file; fare clic su di esso per aprire quel file. Premere Esc per cancellare.
  • Copia nome copia il nome qualificato di un elemento, come ISQ::MassValue, da usare nell'Editor.
  • Mostra testo mostra il file della libreria come è scritto; Mostra definizioni torna alle tabelle.

La libreria è la libreria della release SysML v2, con una correzione: una tonne (alias 'metric ton') si converte in 1000 kg; il file della release indica 0,001 kg. Il modello vi fa riferimento per nome; non viene copiata nel progetto e non fa parte di un'esportazione .sysml.

Limiti

  • Un documento di testo più grande di 8 MB non viene controllato: This text is larger than 8 MB and is not checked. Split it into several packages.
  • Una riga più lunga di 64 KB non viene controllata.
  • Un annidamento con più di 256 livelli non viene controllato.
  • La libreria standard non può essere modificata.

SysML® e OMG® sono marchi registrati di Object Management Group, Inc. negli Stati Uniti e in altri paesi.