Guida · SysML v2
Spostare un modello SysML v1 in SysML v2: una migrazione passo per passo
Un modello SysML v1 si può convertire automaticamente in SysML v2, ma una migrazione è più di una conversione di file: qualcuno deve decidere come dovrebbe essere il modello convertito e controllare che dica ancora ciò che diceva il modello v1. Questa guida illustra una migrazione in otto passi, dall’inventario del modello v1 al passaggio definitivo, con un piccolo modello convertito e letto riga per riga.
In questa pagina
- Prima di iniziare: una traduzione, non un aggiornamento
- 1. Fare l’inventario del modello v1
- 2. Esportare il modello dallo strumento SysML v1
- 3. Convertire un pacchetto pilota
- 4. Leggere il rapporto di conversione
- Un esempio svolto: il modello di un piccolo rover
- 5. Rielaborare ciò che è stato approssimato o omesso
- 6. Ricostruire le viste importanti
- 7. Controllare e rivedere il modello v2
- 8. Convertire il resto e passare al nuovo modello
- Checklist di migrazione
- Dove andare dopo
Prima di iniziare: una traduzione, non un aggiornamento
SysML v2 è un nuovo linguaggio, non una nuova versione del formato di file di SysML v1. I blocchi diventano definizioni di parti, le porte sono tipizzate da definizioni di porte, i requisiti contengono condizioni e i diagrammi diventano viste definite dal modello. SysML v1 e v2 a confronto spiega le differenze una per una.
Un convertitore svolge la parte meccanica: ogni elemento che ha un corrispondente in SysML v2 viene scritto in SysML v2, e il resto viene segnalato. Ciò che un convertitore non può fare è decidere come il team vuole usare il nuovo linguaggio. Pianificare la migrazione come un’attività di modellazione con un responsabile, una revisione e un momento in cui il modello v2 diventa il riferimento.
Questa guida usa il convertitore di Holarch, che importa un modello SysML 1.x in un progetto SysML v2 e segnala ogni elemento come convertito, approssimato od omesso. I passi di pianificazione valgono per qualsiasi convertitore.
1. Fare l’inventario del modello v1
Prima di esportare qualsiasi cosa, scoprire che cosa contiene il modello e chi ne dipende. Un breve inventario evita rielaborazioni in seguito.
- Pacchetti e responsabili. Elencare i pacchetti di primo livello, chi mantiene ciascuno e quali sono citati da altri modelli o documenti. I pacchetti sono l’unità che si convertirà e rivedrà.
- Diagrammi importanti. Annotare i diagrammi che le persone usano davvero nelle revisioni e nei documenti. I layout dei diagrammi non passano a SysML v2, quindi questi diventano viste da ricostruire.
- Profili e stereotipi. Elencare i propri stereotipi e i loro tagged value. Diventano definizioni di metadati, e il loro significato nel nuovo modello va concordato di nuovo.
- Comportamento scritto come codice. Comportamenti opachi, guardie e vincoli in OCL, in un linguaggio di azioni o negli script di uno strumento vengono conservati come testo nel linguaggio originale; non vengono tradotti.
- Elementi senza nome. Le relazioni che puntano a elementi senza nome non si possono scrivere nel testo SysML v2, che fa riferimento agli elementi per nome. Dare subito un nome agli elementi verso cui si traccia, nello strumento v1.
- Dimensioni. Holarch converte un file alla volta, fino a 64 MB e 250.000 elementi. I modelli più grandi si esportano un pacchetto alla volta.
2. Esportare il modello dallo strumento SysML v1
Il convertitore legge il modello da XMI, il formato di scambio scritto dagli strumenti SysML v1. Ogni strumento lo esporta in modo leggermente diverso:
| Strumento | Che cosa importare |
|---|---|
| Cameo Systems Modeler, MagicDraw | Il file di progetto .mdzip, oppure File → Export To → Eclipse UML2 (v5.x) XMI File e il file .xmi |
| Enterprise Architect | Selezionare il pacchetto, Publish → Export XML, scegliere XMI 2.1 e importare il file .xml. I file di progetto (.eap, .qea) non vengono letti direttamente. |
| IBM Rhapsody | Un’esportazione XMI 2.x dal toolkit XMI |
| Eclipse Papyrus | Il file .uml del modello |
Conservare il file esportato con la documentazione della migrazione: è l’input v1 esatto a cui fa riferimento la revisione.
3. Convertire un pacchetto pilota
Iniziare con un pacchetto rappresentativo ma non il più grande: un sottosistema con struttura, interfacce, un po’ di comportamento e i suoi requisiti. Il pilota mostra come appare la conversione del proprio modello prima di impegnarvi l’intero team.
- Creare un progetto SysML v2, o aprire quello in cui dovrà finire il modello convertito, e fare clic su Modello → Importazione ed esportazione.
- In Importa, scegliere In un nuovo progetto SysML v2 per un pilota, così che nient’altro venga toccato.
- Trascinare il file esportato nel riquadro. Una scheda di avanzamento mostra le fasi: lettura del file XMI, conversione in SysML v2, controllo del risultato.
Non è ancora stato importato nulla. La schermata successiva è l’anteprima con il rapporto di conversione.
4. Leggere il rapporto di conversione
Conversione da SysML v1, in cima all’anteprima, riporta il numero di elementi convertiti, approssimati e omessi, e se il testo SysML v2 supera i controlli senza problemi. Ogni elemento del modello v1 ha un solo esito:
- Convertito: l’elemento ha un corrispondente diretto in SysML v2, come un blocco che diventa una
part def. - Approssimato: l’elemento è conservato in forma modificata, per esempio una transizione attraverso una scelta che diventa una transizione per ogni percorso. Sono i punti in cui il significato può differire dal modello v1.
- Omesso: SysML v2 non ha un corrispondente, oppure l’elemento punta a qualcosa che non si trova nel file.
Usare Mostra per elencare gli elementi approssimati e omessi. Ogni riga riporta l’elemento, il suo tipo SysML v1, ciò che è diventato con il suo nome SysML v2, e il motivo. Aprire Mostra il testo SysML v2 per leggere il risultato e fare clic su Scarica report per conservare il rapporto come file CSV. Il CSV è l’elenco di lavoro del passo 5: ordinarlo per motivo e assegnare un responsabile a ogni gruppo.
Un esempio svolto: il modello di un piccolo rover
Un piccolo modello SysML v1 del percorso di alimentazione di un rover planetario, in tre pacchetti:
| Pacchetto | Elementi SysML v1 |
|---|---|
| Tipi | Un value type Power con l’unità W; un blocco Charge; un interface block Power Interface con due flow property in uscita, charge (un Charge) e voltage (un Real) |
| Struttura | Un blocco incapsulato Rover con le part property battery e computer, una value property power budget di 120 W, un connettore power bus tra le loro porte e un item flow power flow di Charge su di esso. Un blocco Battery con una proxy port out; un blocco Computer con una proxy port coniugata in e una full port raw. Entrambi hanno uno stereotipo utente «Hardware» con tagged value. Un’associazione con un estremo posseduto dall’associazione stessa. |
| Requisiti | I requisiti R-1 Mission e R-2 Power Margin; R-2 derivato da R-1; R-2 soddisfatto dalla parte battery; una traccia da Computer a Battery |
Una volta convertito, si legge così. Il listato è l’output del convertitore, invariato:
package 'Rover Model' {
package Types {
attribute def Power :> ISQ::PowerValue;
part def Charge;
port def 'Power Interface' {
out item charge : Charge;
out attribute voltage : ScalarValues::Real;
}
}
package Structure {
part def Rover {
doc /* Six-wheeled science rover. */
@SysMLv1Library::BlockData { isEncapsulated = true; }
part battery : Battery;
part computer : Computer;
attribute 'power budget' : Types::Power = 120 [SI::W];
connection 'power bus' connect battery.'out' to computer.'in';
satisfy Requirements::'Power Margin' by battery;
flow 'power flow' of Types::Charge from battery.'out' to computer.'in';
}
part def Battery {
@'SysML v1 Profiles'::rov::Hardware { qualified = "true"; vendor = "Acme Cells"; }
port 'out' : Types::'Power Interface';
attribute capacity : Types::Power;
}
part def Computer {
@'SysML v1 Profiles'::rov::Hardware { vendor = "Orbital Logic"; }
port 'in' : ~Types::'Power Interface';
part raw : Types::Charge {
@SysMLv1Library::PortData { isFullPort = true; }
}
}
}
package Requirements {
requirement <'R-1'> Mission {
doc /* The rover shall explore the landing site. */
}
requirement <'R-2'> 'Power Margin' {
doc /* Keep a 50 % power margin. */
}
connection : DerivationConnections::Derivation connect 'Power Margin' to Mission;
dependency from Structure::Computer to Structure::Battery {
@SysMLv1Library::TraceData { isTrace = true; }
}
}
}
package 'SysML v1 Profiles' {
package rov {
metadata def Hardware {
attribute qualified : ScalarValues::String;
attribute vendor : ScalarValues::String;
}
}
}
Che cosa è successo a ogni parte del modello v1:
- Value type con unità. Power in watt specializza
ISQ::PowerValuedella libreria standard, e il valore predefinito è scritto con la sua unità:120 [SI::W]. Un value type la cui unità non è un’unità SI mappata resta un numero reale, con l’unità nella documentazione, e viene segnalato come approssimato. - Blocchi e proprietà. I blocchi diventano
part defe le part property diventanopart. La proprietà isEncapsulated del blocco non ha una parola chiave SysML v2, quindi viene conservata come metadatoSysMLv1Library::BlockData. - Interface block e porte. L’interface block diventa una
port defle cui flow property sono feature orientate:out itemper quella tipizzata da un blocco,out attributeper il valore. La proxy port coniugata è tipizzata~Types::'Power Interface'. La full port diventa una parte con il metadatoSysMLv1Library::PortData, perché una porta SysML v2 è tipizzata da una definizione di porta. - Connettore e item flow. Il connettore diventa una
connectiontra le due porte, e l’item flow su di esso unflowdi Charge tra le stesse porte. - Requisiti. Ogni requisito conserva il suo id come nome breve,
<'R-1'>, e il suo testo comedoc. La relazione di soddisfacimento si trova nel blocco che possiede la parte che soddisfa; la relazione di derivazione diventa una connessione di derivazione; la traccia diventa una dipendenza conSysMLv1Library::TraceData. - Lo stereotipo utente. «Hardware» diventa una
metadata defin un pacchetto'SysML v1 Profiles', applicata a ogni blocco con i suoi tagged value. Le sue due applicazioni sono segnalate come approssimate: i tagged value sono diventati attributi di testo, qualunque fosse il loro tipo nel profilo. - L’associazione. Un’associazione senza classe qui non ha un corrispondente SysML v2, e nemmeno il suo estremo posseduto dall’associazione viene convertito. Entrambi sono segnalati come omessi; le proprietà sui blocchi portano la struttura.
Il rapporto per questo modello: 31 elementi, 27 convertiti, 2 approssimati, 2 omessi, e il testo supera i controlli senza errori né avvisi. I nomi che non sono semplici identificatori, come 'power budget' o 'out' (una parola chiave SysML v2), sono racchiusi tra apici per mantenere la grafia v1.
5. Rielaborare ciò che è stato approssimato o omesso
Esaminare le righe approssimate e omesse del rapporto per motivo. La maggior parte dei motivi richiede una tra poche decisioni:
| Che cosa dice il rapporto | Che cosa decidere |
|---|---|
| Una porta è tipizzata da un blocco che non è un interface block; è diventata una porta senza tipo | Definire una definizione di porta con le feature che attraversano il confine, e tipizzare la porta con essa. |
| Transizioni attraverso una scelta, una giunzione, un fork o un join; ogni percorso è diventato una transizione | Controllare che le guardie unite dicano ancora ciò che intendeva il diagramma v1; semplificare dove i percorsi sono ora più leggibili. |
| Un trigger è conservato come documentazione | Riscrivere i trigger di cambiamento e di tempo come trigger SysML v2 dove il significato è chiaro, come accept after una durata. |
| Un’unità non è un’unità SI mappata da Holarch; il value type è un numero reale | Decidere se una grandezza standard è adatta, oppure mantenere il numero reale e l’unità documentata. |
| Un tipo di azione diverso da call, opaque o accept action è diventato un’azione semplice | Riscrivere le send e le altre azioni specifiche con l’azione SysML v2 che fa la stessa cosa. |
| Le partizioni di attività non vengono convertite | Indicare quale parte fa che cosa con perform nella parte, invece di una corsia. |
| Punta a un elemento senza nome | Dare un nome all’elemento di destinazione nello strumento v1 e convertire di nuovo, oppure aggiungere la relazione nel modello v2. |
| Il suo nome è usato due volte nello stesso punto; rinominato con un suffisso | Dare a ogni elemento un nome che dica che cos’è. |
| I tagged value sono diventati attributi di testo del metadato | Dare agli attributi del metadato i tipi necessari, e concordare che cosa significa ora ogni stereotipo. |
Due tipi di testo vanno esaminati anche quando la conversione è pulita. I corpi opachi sono conservati come rappresentazioni testuali nel linguaggio originale, come language "OCL" /* … */; Holarch controlla solo i corpi scritti in SysML o KerML, quindi riscrivere una guardia o un vincolo come espressione SysML dove il modello deve valutarli. Inoltre le traduzioni letterali conservano gli espedienti di v1, come i tipi specifici di proprietà creati solo per impostare un valore: in SysML v2 sono semplici ridefinizioni sugli usi. Che cosa va ripensato elenca i casi comuni.
6. Ricostruire le viste importanti
I diagrammi e il loro layout non vengono convertiti. Riprendere l’elenco dei diagrammi del passo 1 e creare una vista per ognuno ancora necessario: una vista generale per struttura e requisiti, una vista di interconnessione per parti e connessioni, una vista di flusso d’azioni per le attività, una vista di transizione di stato per le macchine a stati. Ricostruire solo ciò che le persone usano; il modello contiene comunque tutto il resto. Si veda il riferimento sulle viste.
7. Controllare e rivedere il modello v2
- Il testo supera i controlli. L’importazione mostra il controllo del testo convertito prima che cambi qualsiasi cosa; dopo la rielaborazione, l’Editor segnala i nuovi problemi durante la digitazione.
- I conteggi corrispondono. Confrontare alcuni numeri tra il modello v1 e il modello v2: requisiti, parti, porte, connessioni, relazioni di verifica. Una differenza che il rapporto non spiega merita un controllo.
- Chi usa il modello lo rivede. Percorrere il pacchetto pilota con i suoi responsabili, a partire dagli elementi approssimati e dalle viste ricostruite.
- Registrare le decisioni. Mettere per iscritto gli schemi di modellazione scelti per porte, trigger, unità e stereotipi, così che il resto della migrazione li segua.
8. Convertire il resto e passare al nuovo modello
Convertire i pacchetti rimanenti uno alla volta, nello stesso progetto SysML v2. Ogni importazione mostra la stessa anteprima: un pacchetto già presente nel progetto appare come Modificato o Invariato, uno nuovo come Nuovo, e si scelgono i pacchetti da importare. Ogni importazione è un solo passo di annullamento.
Mantenere il modello v1 come riferimento finché il modello v2 non è stato rivisto, poi congelarlo e fare del progetto SysML v2 il modello di riferimento ufficiale. Da quel momento le modifiche vanno solo nel modello v2.
Checklist di migrazione
- Pacchetti, responsabili e diagrammi importanti sono elencati.
- Gli elementi a cui puntano le relazioni hanno un nome.
- Il file XMI esportato è conservato con la documentazione della migrazione.
- Un pacchetto pilota è convertito, il suo rapporto scaricato, e ogni riga approssimata od omessa ha una decisione.
- Gli schemi di modellazione per porte, trigger, unità e stereotipi sono messi per iscritto.
- Le viste necessarie sono ricostruite; il testo supera i controlli.
- Gli utenti del modello hanno rivisto il pilota.
- I pacchetti rimanenti sono convertiti allo stesso modo, e il modello v1 è congelato.
Dove andare dopo
- Da SysML v1 a SysML v2 in Holarch: che cosa legge e scrive il convertitore, e l’esempio del CubeSat EO-1.
- Importare modelli SysML v1: ogni passo, mappatura, limite e messaggio nei Docs.
- SysML v1 e v2 a confronto: in che cosa differiscono i due linguaggi.
- Tutorial di SysML v2: costruire un modello nella notazione testuale.
- Copertura del linguaggio SysML v2: che cosa supportano i progetti SysML v2 e le lacune note.
Cameo Systems Modeler, MagicDraw, Enterprise Architect, Rhapsody ed Eclipse Papyrus sono marchi dei rispettivi proprietari. Holarch non è affiliato a essi né approvato da essi.