SysML V2 Pilot Implementation

https://github.com/systems-modeling/sysml-v2-pilot-implementation
Admin
This project is a pilot implementation of the Systems Modeling Language (SysML) Version 2, providing...
Tokens:6,587
Snippets:34
Trust Score:8.9
License:LGPL-3.0
Update:11 months ago
Show doc for...
Tokens:
Raw
### Java Copyright License Header Template

Source: https://github.com/systems-modeling/sysml-v2-pilot-implementation/blob/master/README.adoc

A template for adding a copyright license header to new Java files in the SysML 2 Pilot Implementation project. The header includes GNU LGPL v3.0 license information and SPDX tagging.

```Java
/**
 * SysML 2 Pilot Implementation
 * Copyright (C) 2025 <Your organization name>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * @license LGPL-3.0-or-later <http://spdx.org/licenses/LGPL-3.0-or-later>
 */
```

--------------------------------

### Build and package SysML v2 project with Maven (bash)

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

Demonstrates building all modules, installing to the local Maven repository, skipping tests for speed, building a specific module, and generating documentation. Dependencies: Maven Wrapper, project structure. Inputs: no args or paths; Outputs: artifacts under target/repository and target directories.

```bash
# Build all modules
cd SysML-v2-Pilot-Implementation
./mvnw clean package

```

```bash
# Build output locations:
# - Eclipse update site: org.omg.sysml.site/target/repository/
# - Interactive JAR: org.omg.sysml.interactive/target/org.omg.sysml.interactive-all.jar
# - Jupyter kernel: org.omg.sysml.jupyter.kernel/target/sysml-jupyter-kernel-*.zip

```

```bash
# Install to local Maven repository
./mvnw install

```

```bash
# Skip tests for faster build
./mvnw clean package -Dxpect.tests.skip=true

```

```bash
# Build specific module
cd org.omg.sysml.interactive
mvn clean package

```

```bash
# Generate documentation
mvn asciidoctor:process-asciidoc

```

--------------------------------

### Launch Interactive SysML v2 REPL Shell

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

Starts an interactive SysML v2 REPL shell for parsing, validating, and executing models. Requires the SysML library path as argument. Supports optional API repository connection for remote model management.

```bash
# Start interactive shell with library path
java -jar org.omg.sysml.interactive-all.jar /path/to/sysml.library

# Start with library and API repository connection
java -jar org.omg.sysml.interactive-all.jar /path/to/sysml.library http://sysml2-dev.intercax.com:9000

# Interactive session example
SysML> package VehicleModel {
         part def Vehicle {
           attribute mass : ISQ::MassValue;
         }
         part myVehicle : Vehicle;
       }
[OK] Parsed successfully

SysML> %list
Available packages:
  - VehicleModel
  - Kernel Libraries
  - Systems Library

SysML> %show VehicleModel
Abstract syntax tree for VehicleModel displayed

SysML> %viz VehicleModel
[SVG diagram generated and displayed]
```

--------------------------------

### Configure SysML v2 in Eclipse IDE - Bash

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

This Bash script outlines steps to configure and run SysML v2 models in Eclipse Modeling Tools with Xtext and PlantUML support. It requires Eclipse Modeling Tools, Xtext SDK, and PlantUML installations. Inputs are manual Eclipse setup steps; outputs are built projects and runtime instances. Limitations include manual installation dependencies and specific Eclipse version requirements.

```bash
# Eclipse setup (manual installation)
# 1. Install Eclipse Modeling Tools 2025-03
# 2. Install Xtext Complete SDK from http://download.eclipse.org/releases/2025-03
# 3. Install PlantUML from https://github.com/himi/p2-update-puml-sysmlv2/raw/main/updates

# Build the project
cd SysML-v2-Pilot-Implementation
mvn clean package

# Launch Eclipse runtime (from Eclipse IDE)
# Right-click org.omg.sysml > Run As > Eclipse Application

# In runtime Eclipse:
# 1. Import projects: kerml, sysml, sysml.library
# 2. Build sysml.library first: Project > Clean (select only sysml.library)
# 3. Build kerml and sysml: Project > Clean (select kerml and sysml)

# Create new SysML project:
# File > New > Project > General/Project
# Right-click project > Configure > Convert to Xtext project
# Add sysml.library to Project References in project Properties
```

--------------------------------

### Define and execute state machines (SysML)

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

Provides a SysML DSL example for a TrafficLight state machine with states and transitions, suitable for interactive shells or Jupyter kernels. Dependencies: SysML editor/kernel support. Inputs/outputs: model blocks and optional viz commands.

```sysml
package StateMachineExample {
    private import ScalarValues::*;

    part def TrafficLight {
        state def TrafficLightStates {
            entry; then red;

            state red;
            transition red_to_green
                first red
                then green
                when after(30[s]);

            state green;
            transition green_to_yellow
                first green
                then yellow
                when after(45[s]);

            state yellow;
            transition yellow_to_red
                first yellow
                then red
                when after(5[s]);
        }
    }

    part myLight : TrafficLight;
}

# In interactive shell or Jupyter:
# %show StateMachineExample::TrafficLight
# %viz StateMachineExample::TrafficLight --view state

```

--------------------------------

### Manage SysML Libraries and Indexing - Java

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

This Java example loads and queries the SysML v2 standard library, including Kernel, Systems, and ISQ quantities. It depends on SysMLInteractive, library index providers, and Xtext resources. Inputs are library paths and model strings; outputs include listed libraries and queried elements. Limitations are tied to library file availability and index provider configuration.

```java
import org.omg.sysml.interactive.SysMLInteractive;
import org.omg.kerml.xtext.library.ILibraryIndexProvider;
import org.eclipse.xtext.resource.IEObjectDescription;
import org.omg.sysml.lang.sysml.Package;

SysMLInteractive interactive = SysMLInteractive.getInstance();

// Load library from directory
interactive.loadLibrary("/path/to/sysml.library");

// List available library packages
String libraryList = interactive.list(null);
System.out.println("Available libraries:\n" + libraryList);

// Query specific library elements
ILibraryIndexProvider indexProvider = interactive.getLibraryIndexProvider();
Iterable<IEObjectDescription> massUnits = indexProvider.getVisibleElements("ISQ::MassValue");

for (IEObjectDescription desc : massUnits) {
    System.out.println("Found: " + desc.getQualifiedName());
}

// Use library elements in models
String modelWithISQ = """
    package SensorModel {
        private import ISQ::*;
        private import SI::*;

        part def TemperatureSensor {
            attribute reading : TemperatureValue;
            attribute range : TemperatureValue[2] = (
                -40.0[Cel],
                125.0[Cel]
            );
        }
    }
    """;
interactive.process(modelWithISQ);
```

--------------------------------

### Publish SysML Models to a Remote Repository with Java

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

This example demonstrates how to publish SysML models to a remote REST API repository using Java and the ProjectRepository utility. It connects to a repository, lists existing projects, gets or creates a project and branch, prepares the model for publishing, and then commits the model to the repository.

```java
import org.omg.sysml.util.repository.ProjectRepository;
import org.omg.sysml.util.repository.RemoteProject;
import org.omg.sysml.util.repository.RemoteProject.RemoteBranch;
import org.omg.sysml.util.repository.APIModel;
import org.eclipse.emf.ecore.resource.Resource;

// Connect to repository
ProjectRepository repository = new ProjectRepository("http://sysml2-dev.intercax.com:9000");

// List existing projects
List<RemoteProject> projects = repository.getProjects();
for (RemoteProject project : projects) {
    System.out.println("Project: " + project.getName() + " (ID: " + project.getId() + ")");
}

// Create or get a project
RemoteProject project = repository.getOrCreateProject("VehicleDesign");

// Get or create a branch
RemoteBranch branch = project.getOrCreateBranch("main");

// Prepare model for publishing
Resource modelResource = loadSysMLModel("/path/to/model.sysml");
APIModel apiModel = new APIModel();
apiModel.addFromResource(modelResource);

// Publish to repository
String commitMessage = "Initial vehicle model commit";
branch.commit(apiModel, commitMessage);

System.out.println("Model published successfully to " + project.getName() + "/main")
```

--------------------------------

### Execute SysML v2 in Jupyter Notebooks

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

Enables SysML v2 execution within Jupyter notebooks using magic commands. Requires kernel installation and supports model visualization, evaluation, and repository operations.

```python
# Install kernel (run once)
# python3 install.py --sys-prefix

# Start Jupyter with SysML kernel
# jupyter console --kernel=sysml
# jupyter lab

# In Jupyter notebook cell:
package CalculationExample {
    private import ISQ::*;

    part def VehiclePart {
        attribute m : MassValue;
    }

    part vehicle : VehiclePart {
        part eng : VehiclePart;
        part trans : VehiclePart;
    }

    calc def MassSum {
        in partMasses : MassValue[0..*];
        return totalMass : MassValue = sum(partMasses);
    }
}

# Use magic commands
%list                          # List all packages
%eval vehicle.eng.m           # Evaluate expression
%viz vehicle                  # Generate PlantUML visualization
%export vehicle --format json # Export to JSON
%publish myproject            # Publish to repository
%load myproject/main          # Load from repository
```

--------------------------------

### Load SysML Models from Repository - Java

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

This Java example loads SysML models from a remote repository by specifying project, branch, and commit details. It depends on OMG SysML repository utilities and EMF Ecore resources for connectivity. Inputs include repository URL, project name, and branch; outputs are lists of model elements queried by qualified names. Limitations involve remote repository availability and API version compatibility.

```java
import org.omg.sysml.util.repository.ProjectRepository;
import org.omg.sysml.util.repository.RemoteProject;
import org.omg.sysml.util.repository.RemoteProject.RemoteBranch;
import org.omg.sysml.model.Commit;
import org.eclipse.emf.ecore.resource.Resource;

// Connect to repository
ProjectRepository repository = new ProjectRepository("http://sysml2-dev.intercax.com:9000");

// Get project and branch
RemoteProject project = repository.getProject("VehicleDesign");
RemoteBranch branch = project.getBranch("main");

// Get latest commit
Commit latestCommit = branch.getHeadCommit();
System.out.println("Loading commit: " + latestCommit.getId());
System.out.println("Message: " + latestCommit.getName());

// Load model elements from repository
List<org.omg.sysml.model.Element> elements = branch.getElements();
System.out.println("Loaded " + elements.size() + " elements");

// Query specific elements by qualified name
List<org.omg.sysml.model.Element> vehicleElements =
    branch.queryByQualifiedName("VehicleDesign::Vehicle");

for (org.omg.sysml.model.Element element : vehicleElements) {
    System.out.println("Element: " + element.getName());
    System.out.println("Type: " + element.getAtType());
}
```

--------------------------------

### Export SysML Models to JSON - Java

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

This Java code exports SysML models to JSON format for interoperability with other tools. It requires SysMLInteractive, traversal utilities, and JSON facade libraries. Inputs are a model definition string and a root element; outputs are JSON strings written to files. Limitations include reliance on interactive instance setup and file system permissions for writing.

```java
import org.omg.sysml.interactive.SysMLInteractive;
import org.omg.sysml.util.traversal.Traversal;
import org.omg.sysml.util.traversal.facade.impl.JsonElementProcessingFacade;
import org.omg.sysml.lang.sysml.Element;
import java.io.FileWriter;

SysMLInteractive interactive = SysMLInteractive.getInstance();
interactive.loadLibrary("/path/to/sysml.library");

// Load a model
String model = """
    package ExportExample {
        part def Sensor {
            attribute serialNumber : String;
            attribute calibrationDate : String;
        }
        part tempSensor : Sensor;
    }
    """;
interactive.process(model);

// Get the root element
Element rootElement = interactive.findElement("ExportExample");

// Export to JSON
JsonElementProcessingFacade jsonFacade = new JsonElementProcessingFacade();
Traversal traversal = new Traversal(jsonFacade);
traversal.traverse(rootElement);

String jsonOutput = jsonFacade.getJsonOutput();

// Write to file
try (FileWriter writer = new FileWriter("model.json")) {
    writer.write(jsonOutput);
    System.out.println("Model exported to model.json");
}
```

--------------------------------

### Model requirements with traceability (SysML)

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

Shows a SysML requirements model with a PerformanceRequirement, a topSpeed constraint, and a verification test relationship. Dependencies: SysML DSL support. Inputs/outputs: a requirements model with definitions, constraints, and verifications.

```sysml
package RequirementsExample {
    requirement def PerformanceRequirement {
        doc /* Base definition for performance requirements */
        subject vehicle : Vehicle;
    }

    requirement topSpeed : PerformanceRequirement {
        doc /* The vehicle shall achieve a top speed of at least 120 mph. */
        subject vehicle;
        require constraint { vehicle.maxSpeed >= 120[mi/h] }
    }

    part def Vehicle {
        attribute maxSpeed : ISQ::SpeedValue;
    }

    part sportsCar : Vehicle {
        attribute ::> maxSpeed = 150[mi/h];
        satisfy topSpeed by sportsCar;
    }

    verification def TopSpeedTest {
        verify requirement topSpeed;
        use testVehicle : Vehicle;
    }
}

# Query requirements:
# %list requirements
# %show RequirementsExample::topSpeed

```

--------------------------------

### Python Kernel Argument Parsing Configuration

Source: https://github.com/systems-modeling/sysml-v2-pilot-implementation/blob/master/org.omg.sysml.jupyter.kernel/README.DEV.md

This Python code demonstrates how to add a new command-line argument to the kernel's argument parser using `parser.add_argument`. It includes configurations for environment variable action, aliases, help text, and type assertions.

```python
#     kernelParameters {
#        list('library-path', 'ISYSML_LIBRARY_PATH') {
#            separator = PATH_SEPARATOR
#            description = '''A file path separator delimited list of library path entries that should be available to the user code. **Important:** no matter what OS, this should use forward slash "/" as the file separator.&#39;&#39;&#39;
#        }
#        string('api-base-path', 'ISYSML_API_BASE_PATH') {
#            description = '''The base path for the API that the model is published to using the %publish magic command.&#39;&#39;&#39;
#        }
#        string('graphviz-path', 'ISYSML_GRAPHVIZ_PATH') {
#            description = '''The path to the Graphviz dot executable that is used for the %viz magic command.&#39;&#39;&#39;
#        }
#    }
#
    parser.add_argument(
        "--library-path",
        dest="env",
        action=EnvVar,
        aliases=ALIASES,
        name_map=NAME_MAP,
        help="A file path separator delimited list of library path entries that should be available to the user code. **Important:** no matter what OS, this should use forward slash \"/\" as the file separator.",
        type=type_assertion("library-path", str),
        list_sep=os.pathsep,
    )
#...
```

--------------------------------

### Python Kernel Configuration: Aliases and Name Mapping

Source: https://github.com/systems-modeling/sysml-v2-pilot-implementation/blob/master/org.omg.sysml.jupyter.kernel/README.DEV.md

This Python snippet shows how to define aliases for environment variables and map them to program arguments within the install.py script. It's crucial for integrating custom arguments into the kernel.

```python
#SECTION START
#This section was generated by the jupyter-kernel-installer plugin

#alias definitions
ALIASES = {
    "ISYSML_LIBRARY_PATH": {
    },
    "ISYSML_API_BASE_PATH": {
    },
    "ISYSML_GRAPHVIZ_PATH": {
    },
}

#aliasing of program arguments. Used in the SysMLKernel.java
#constant for the java implementation can be found in the IsysML.java
NAME_MAP = {
    "library-path": "ISYSML_LIBRARY_PATH",
    "api-base-path": "ISYSML_API_BASE_PATH",
    "graphviz-path": "ISYSML_GRAPHVIZ_PATH",

}
#SECTION END
```

--------------------------------

### Process SysML v2 models from CLI (bash)

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

Shows how to process and validate SysML models non-interactively from the command line. Dependencies: the interactive JAR built earlier. Inputs: model files or streams; Outputs: stdout/stderr or generated artifacts.

```bash
echo \"package test { part def Vehicle; }\" | java -jar org.omg.sysml.interactive-all.jar

```

```bash
cat model1.sysml model2.sysml | java -jar org.omg.sysml.interactive-all.jar /path/to/sysml.library

```

```bash
java -jar org.omg.sysml.interactive-all.jar /path/to/sysml.library <<EOF
package VehicleModel {
    part def Vehicle {
        part engine : Engine;
        part transmission : Transmission;
    }
    part def Engine;
    part def Transmission;
}
%viz VehicleModel::Vehicle
%quit
EOF
```

--------------------------------

### Parse and Validate SysML v2 Models

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

Parses SysML v2 textual models and validates them against the language specification. Provides comprehensive error reporting and access to model elements. Requires SysML library path for initialization.

```java
import org.omg.sysml.interactive.SysMLInteractive;
import org.omg.sysml.interactive.SysMLInteractiveResult;

// Initialize the interactive instance
SysMLInteractive interactive = SysMLInteractive.getInstance();
interactive.loadLibrary("/path/to/sysml.library");

// Parse a SysML model
String modelText = """
    package VehicleDefinitions {
        part def Vehicle {
            attribute mass :> ISQ::mass;
        }
        part def Transmission;
        part def Wheel {
            port hub: WheelHubIF;
        }
    }
    """;

SysMLInteractiveResult result = interactive.process(modelText);

if (result.hasErrors()) {
    for (String error : result.getErrors()) {
        System.err.println("Error: " + error);
    }
} else {
    System.out.println("Model parsed successfully");
    System.out.println("Root elements: " + result.getRootElements().size());
}
```

--------------------------------

### JupyterLab/Notebook Syntax Highlighting Generation (Python)

Source: https://github.com/systems-modeling/sysml-v2-pilot-implementation/blob/master/tool-support/syntax-highlighting/README.md

Python script `xtext_grammar_converter.py` to generate syntax highlighting files (`mode.ts` and `kernel.js`) for JupyterLab and Jupyter Notebook. Uses templates and keyword lists extracted from xtext grammars.

```bash
$ cd $GIT_REPO_DIR/tool-support/syntax-highlighting
$ python xtext_grammar_converter.py
```

--------------------------------

### Evaluate SysML Expressions with Java

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

This snippet demonstrates how to evaluate SysML expressions, calculations, and constraints using Java and the SysMLInteractive library. It loads a SysML library, defines a model with calculations, and then evaluates a specific calculation to retrieve a result.

```java
import org.omg.sysml.interactive.SysMLInteractive;
import org.omg.sysml.execution.expressions.ExpressionEvaluator;
import org.omg.sysml.lang.sysml.Expression;

SysMLInteractive interactive = SysMLInteractive.getInstance();
interactive.loadLibrary("/path/to/sysml.library");

// Define a model with calculations
String modelWithCalc = """;"
    package MassCalculation {
        private import ISQ::*;
        private import NumericalFunctions::*;

        calc def MassSum {
            in partMasses : MassValue[0..*];
            return totalMass : MassValue = sum(partMasses);
        }

        calc massCalc : MassSum {
            in partMasses = (100.0[kg], 200.0[kg], 50.0[kg]);
            return totalMass;
        }
    }
    """;

interactive.process(modelWithCalc);

// Evaluate the calculation
String evalResult = interactive.eval("massCalc.totalMass", "MassCalculation");
System.out.println("Total mass: " + evalResult); // Output: 350.0[kg]
```

--------------------------------

### Generate PlantUML Diagrams from SysML Models with Java

Source: https://context7.com/systems-modeling/sysml-v2-pilot-implementation/llms.txt

This code snippet showcases how to generate PlantUML diagrams from SysML models using Java and the SysML2PlantUMLSvc service. It loads a SysML library, defines a vehicle model, and then generates a tree-view PlantUML code or directly renders it to an SVG.

```java
import org.omg.sysml.interactive.SysMLInteractive;
import org.omg.sysml.plantuml.SysML2PlantUMLSvc;
import org.omg.sysml.plantuml.VizOptions;
import org.omg.sysml.lang.sysml.Element;

SysMLInteractive interactive = SysMLInteractive.getInstance();
interactive.loadLibrary("/path/to/sysml.library");

// Load a model
String vehicleModel = """;"
    package VehicleStructure {
        part def Vehicle {
            part engine : Engine;
            part transmission : Transmission;
            part wheels : Wheel[4];
        }
        part def Engine;
        part def Transmission;
        part def Wheel;
    }
    """;
interactive.process(vehicleModel);

// Generate visualization
VizOptions options = new VizOptions();
options.setViewType(VizOptions.ViewType.TREE);
options.setFormat("svg");

Element vehicleElement = interactive.findElement("VehicleStructure::Vehicle");
String plantUMLCode = SysML2PlantUMLSvc.generate(vehicleElement, options);
System.out.println(plantUMLCode);

// Or get SVG directly
byte[] svgData = SysML2PlantUMLSvc.renderToSVG(plantUMLCode, "/path/to/graphviz")
```

--------------------------------

### VS Code Token Color Customizations (JSON)

Source: https://github.com/systems-modeling/sysml-v2-pilot-implementation/blob/master/tool-support/syntax-highlighting/README.md

Customizes token colors in VS Code for KerML and SysML syntax highlighting. Requires editing the `settings.json` file to adjust the appearance of comments, variables, strings, and keywords.

```json
{
  "editor.tokenColorCustomizations": {
    "comments": "#20a060",
    "variables": "#0000ff",
    "strings": "#c00000",
    "textMateRules": [
      {
        "scope": "keyword",
        "settings": {
          "foreground": "#7b0050",
          "fontStyle": "bold"
        }
      },
      {
        "scope": "keyword.operator",
        "settings": {
          "foreground": "#7b0050",
          "fontStyle": "bold"
        }
      },
      {
        "scope": "keyword.control",
        "settings": {
          "foreground": "#7b0050",
          "fontStyle": "bold"
        }
      }
    ]
  }
}
```
Tokens:
Raw