Merge branch 'master' of https://github.com/INTO-CPS-Association/sysml-profile

Author: etiennebrosse

.gitignore

@@ -1 +1,2 @@
-/target/
+target/
+

README.md

@@ -0,0 +1,46 @@
+# INTO-CPS SysML Profile for Modelio Open Source
+
+The **INTO-CPS SysML Profile for Modelio** is an open-source module that extends the SysML language within the Modelio UML tool. This module provides specialized features for modeling and simulating cyber-physical systems (CPS) using the INTO-CPS (Integrated Toolchain for Model-based Design of Cyber-Physical Systems) framework. It is particularly useful for defining and configuring Functional Mock-up Units (FMUs) and generating simulation configurations for the Maestro co-simulation engine.
+
+## Features
+
+- **Architecture Diagram**: Model ports for FMI (Functional Mock-up Interface) input and output parameters. This helps define simulators and their interfaces.
+- **Connections Diagram**: Create instance diagrams to model connections between FMI input and output parameters. Suitable for generating Maestro simulation configuration JSON files.
+- **Design Space Exploration (DSE)**: Support for modeling parameters related to Design Space Exploration.
+- **FMI Model Description Import/Export**: Import and export FMI model descriptions to facilitate interoperability with other tools.
+- **Co-Simulation Configuration Export**: Export co-simulation JSON configurations for the [Maestro](https://into-cps-maestro.readthedocs.io/en/latest/user/getting-started.html) simulation engine.
+
+## Documentation and Resources
+
+- **Installation**: [install INTO-CPS module to Modelio](doc/Installation.md)
+- **Quick Guide**: [INTO-CPS Modelio features](doc/QuickGuide.md)
+- **Examples**: Examples are avalable in the [INTO-CPS application](https://into-cps-association.readthedocs.io/projects/desktop-application/en/latest/first_steps.html) in the SysML area for each example . Additional documentation will be migrated to this repository. Stay tuned for updates.
+
+## TODO
+
+> **Note**: Links in the documentation (e.g., forge.modelio.org) are outdated. All relevant information will be migrated to this repository.
+
+1. **Module Migration**: Update the module to be compatible with the latest version of Modelio Open Source (5.4.00).
+2. **Documentation Migration**: Migrate all documentation, examples, and guides to this repository for easier access and maintenance.
+3. **Bug Fixes and Enhancements**: Address any known issues and add new features based on user feedback.
+
+## Contributing
+
+We welcome contributions from the community! If you'd like to contribute to the development of this module, please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bug fix.
+3. Make your changes and ensure they are well-documented.
+4. Submit a pull request with a detailed description of your changes.
+
+## License
+
+This project is licensed under the [INTO-CPS (GPL3) License](LICENSE). Feel free to use, modify, and distribute it as needed.
+
+## Support
+
+For questions, issues, or feature requests, please open an issue in this repository or contact the maintainers directly.
+
+---
+
+Thank you for using the **INTO-CPS SysML Profile for Modelio**! We hope this tool is helping you with your cyber-physical systems modeling and simulation workflows.

doc/Installation.md

@@ -0,0 +1,93 @@
+# INTO-CPS module for Modelio 
+
+
+## Description  
+
+**Modelio** is a powerful, open-source modeling tool that supports **UML**, **BPMN**, and **SysML** for system modeling. It is highly extensible, allowing users to add custom modules or use existing ones to tailor the tool to their specific needs.  
+
+### Key Features:  
+- **SysML support**: Integrated with UML and BPMN for comprehensive system modeling.  
+- **XMI import/export**: Enables interoperability with other modeling tools.  
+- **Scripting support**: Built-in Jython scripting for automation and customization.  
+- **Extensibility**: Add modules to support additional languages, methodologies, or modeling techniques.  
+
+For community support, visit the [Modelio Forum](http://www.modelio.org/forum/index.html).  
+
+## License  
+Modelio is **open-source software**. The core application is licensed under the **GNU GPL**, while the module runtime (used for developing extensions) is licensed under the **Apache License**. This provides flexibility for reuse and embedding.  
+
+For full licensing details, visit the [Modelio License Page](http://www.modelio.org/about-modelio/license.html).  
+
+---
+
+## Download and Installation  
+
+### Current Version  
+The latest stable version of Modelio is **5.4.1**.  
+
+### Download  
+Binary distributions for **Windows** and **Linux** are available on the [Modelio Download Page](http://www.modelio.org/downloads/download-modelio.html).  
+
+### Installation Instructions  
+1. Download the appropriate binary archive for your operating system.  
+2. Extract the archive to your desired installation directory.  
+3. Follow the instructions in the [Modelio Quick Start Guide](https://github.com/ModelioOpenSource/Modelio/wiki) for setup and configuration.  
+
+For version-specific details, refer to the [Modelio Version History](https://github.com/ModelioOpenSource/Modelio/releases).  
+
+---
+
+## Installing the INTO-CPS Module  
+
+The **INTO-CPS module** extends Modelio's capabilities for system modeling, particularly for cyber-physical systems.  
+
+### Resources  
+- **Documentation**: [INTO-CPS Documentation](todo) *(link to be updated)*.  
+- **Latest Releases**: [INTO-CPS Releases](https://github.com/INTO-CPS-Association/sysml-profile/releases).  
+- **Issue Reporting**: [Report an Issue](https://github.com/INTO-CPS-Association/sysml-profile/issues/new).  
+
+### Installation Steps  
+1. Download the latest INTO-CPS module (`.jmdac` file) from the [Releases Page](https://github.com/INTO-CPS-Association/sysml-profile/releases).  
+2. Add the module to the Modelio module catalog.  
+
+---
+
+## Adding the INTO-CPS Module to Modelio  
+
+### Step 1: Open the Modules Catalog  
+1. Launch Modelio.  
+2. Navigate to **Configuration** > ![2] **Modules Catalog...**. 
+
+![1]
+
+### Step 2: Add the Module  
+1. Click **Add a module to the catalog...**.  
+2. Use the file browser to locate and select the downloaded `.jmdac` file.  
+3. Click **OK** to add the module to the catalog.  
+
+### Step 3: Install the Module in a Project
+
+
+
+1. Open or create a project in Modelio.  
+2. Expand the **Modules Catalog** by clicking the [![4]] icon.  
+3. Select the **INTO-CPS module** from the catalog.  
+4. Click the [![5]] icon to install the module in your project.
+
+![3]
+
+   [1]: img/module_catalog.png
+   [2]: img/modulecatalog.png
+   [3]: img/en-installingmodules.png
+   [4]: img/maximize.png
+   [5]: img/add.png
+
+
+---
+
+## Modelio Documentation  
+For further guidance, refer to the following resources:  
+- [Modelio User Manual](https://github.com/ModelioOpenSource/Modelio/wiki/Modelio-User-Documentation) *(wiki)*.  
+- [Installing and Configuring Modules](https://github.com/ModelioOpenSource/Modelio/wiki/Modeler-_modeler_managing_projects_configuring_project_modules) *(wiki)*.  
+
+---

doc/QuickGuide.md

@@ -0,0 +1,99 @@
+# INTO-CPS Diagrams  
+
+Two specialized diagrams have been defined within the INTO-CPS project to support system modeling:  
+
+---
+
+## 1. Architecture Diagram  
+- **Purpose**: Specializes the SysML block diagram to specify a system's architecture in terms of its components.  
+- **Creation**:  
+  1. Right-click on a **Package** in the Modelio project explorer.  
+  2. Select **Create Diagram** > **Architecture Diagram** from the context menu.  
+  3. Name the diagram and start defining the system architecture.  
+
+![1]
+
+*Screenshot: Creating an Architecture Diagram.*  
+
+---
+
+## 2. Connection Diagram  
+- **Purpose**: Specializes the SysML internal block diagram to describe the internal configuration and connections between system components.  
+- **Creation**:  
+  1. Right-click on a **SysML Block** in the Modelio project explorer.  
+  2. Select **Create Diagram** > **Connection Diagram** from the context menu.  
+  3. Name the diagram and define the internal connections.  
+
+![2]
+
+*Screenshot: Creating a Connection Diagram.*  
+
+---
+
+
+
+# FMI Features  
+
+The INTO-CPS module provides two commands to integrate SysML modeling with the **Functional Mock-up Interface (FMI)** standard, specifically the `modelDescription.xml` file defined in the [FMI 2.0 Specification][5].  
+
+---
+
+## 1. FMI Import  
+- **Purpose**: Imports a `modelDescription.xml` file to create a corresponding SysML Block in Modelio.  
+- **Steps**:  
+  1. Right-click on a **Package** in the Modelio project explorer.  
+  2. Select **INTO-CP module** > **Reverse FMI** from the context menu.  
+  3. Browse and select the `modelDescription.xml` file to import.  
+
+![3]
+
+*Screenshot: Importing an FMI file.*  
+
+---
+
+## 2. FMI Export  
+- **Purpose**: Exports a SysML Block as a `modelDescription.xml` file. Note that this only exports the interface description, not the behavior.  
+- **Steps**:  
+  1. Right-click on a **SysML Block** in the Modelio project explorer.  
+  2. Select **INTO-CPS module** > **Generate FMI** from the context menu.  
+  3. Choose the destination folder and save the file.  
+
+![4]
+
+*Screenshot: Exporting an FMI file.*  
+
+---
+
+# Connection Export  
+
+## Generating a Configuration from a BlockInstance  
+- **Purpose**: Exports the configuration of a `BlockInstance` as a Maestro co-simulation configuration file in JSON format.  
+- **Steps**:  
+  1. Select the desired `BlockInstance` in the Modelio project explorer.  
+  2. Right-click and choose **INTO-CPS** > **Generate Configuration**.  
+  3. Provide a relevant name for the configuration file.  
+  4. Click **Generate** to create the JSON file.  
+
+![6]
+
+*Screenshot: Generating a configuration.*  
+
+![7]
+
+*Screenshot: Naming the configuration file.*  
+
+---
+
+## References  
+- [FMI 2.0 Specification][5]: Official documentation for the Functional Mock-up Interface standard.  
+
+[1]: img/architecture.png  
+[2]: img/connection.png  
+[3]: img/reversefmi.png  
+[4]: img/generatefmi.png  
+[5]: https://www.fmi-standard.org/downloads  
+[6]: img/sysml-generateconfig.png  
+[7]: img/sysml-configuration-name.png  
+
+---
+ 

doc/UsersGuide.md

@@ -0,0 +1,132 @@
+# Modelio for INTO-CPS SysML modelling
+
+The Modelio tool and its SysML/INTO-CPS
+profile extension provide the diagramming starting point. This section describes the Modelio extension that provides INTO-CPS-specific modelling
+functionality to the SysML modelling approach.
+
+The INTO-CPS extension module is based on the Modelio SysML extension
+module, and extends it in order to fulfill INTO-CPS modelling requirements
+and needs. Figure 28 shows an example of a simple INTO-CPS Architecture
+Structure Diagram under Modelio. This diagram shows a _System_, named
+“System” (An abstract description of an INTO-CPS multi-model)
+, composed of two EComponents of kind _Subsystem_, named “SubSystem” (Abstract descriptions of INTO-CPS constituent models). These Subsystems have an internal Variable called “variable” of type String and expose two FlowPorts named “portIn” and “portOut”. The
+type of data going through these ports is respectively defined by types In and Out of kind StrtType.
+
+![Example INTO-CPS multi-model](img/ug28_multimodel.png)
+
+Figure 28: Example INTO-CPS multi-model.
+
+Figure 29 illustrates the main graphical interface after Modelio and the
+INTO-CPS extension have been installed. Of all the panes, the following
+three are most useful in the INTO-CPS context.
+
+1. The Modelio model browser, which lists all the elements of your model in tree form.
+2. The diagram editor, which allows you to create INTO-CPS design architectures and connection diagrams.
+3. The INTO-CPS property page, in which values for properties of INTOCPS subsystems are specified.
+
+![Modelio for INTO-CPS](img/ug29_modeliogui.png)
+
+
+## Creating a New Project
+
+first step will be to create, as depicted in Figure 30, a Modelio project:
+1. Launch Modelio.
+2. Click on File → Create a project....
+3. Enter the name of the project.
+4. Enter the description of the project.
+6. Click on Create to create and open the project.
+
+
+![alt text](img/ug30_newproject.png)
+
+Once you have successfully created a Modelio project, you have to install the Modelio extensions required for INTO-CPS modelling, i.e. both Modelio SysML and INTO-CPS extensions, as described in the [installation guide](Installation.md)
+
+If both modules have been correctly installed, you should be able to create,
+under any package, an **INTO-CPS Architecture Structure Diagram** in order
+to model the first subsystem of your multi-model. For that, in the Modelio
+model browser, right click on a _Package_ element then in the _INTO-CPS_
+entry, choose _Architecture Structure Diagram_ as shown in Figure 31. Once
+you are sure that the modules have been correctly installed. You are able to
+start your INTO-CPS SysML modelling.
+
+![Creating an Architecture Structure diagram](img/ug31_archi_struct_dia.png)
+Figure 31: Creating an Architecture Structure diagram.
+
+##  Architecture Structure Diagram
+
+INTO-CPS SysML modelling activitIES can be succinctly described as the creation and population of INTO-CPS SysML diagrams.
+
+The Architecture Structure Diagram (ASD) specialises SysML block definition diagrams (BDDs) to support the specification of a multi-model architecture described in terms of a systems components, which will be represented by FMUs.  Figure 31 shows you how to create an Architecture Structure Diagram. 
+
+Figure 32 represents an example of an Architecture Structure Diagram. Besides creating an Architecture Structure Diagram from scratch and specifying by hand the blocks of your system, the INTO-CPS extension allows the user to create a block from an existing _modelDescription.xml_ file. A _modelDescription.xml_ file is an artifact defined in the FMI standard which specifies, in XML format, the public interface of an FMU. 
+
+![Example Architecture Structure diagram](img/ug32_ex_archi_dia.png)
+
+Figure 32: Example Architecture Structure diagram.
+
+To import a _modelDescription.xml_ file:
+1. Right click in the Modelio model browser on a Package element, then in the INTO-CPS entry choose Import Model description, as shown in Figure 33.
+2. Select the desired modelDescription.xml file (or the .fmu file that should contain a modelDescription.xml file ) in your installation and click on Import (Figure 34).
+
+![Importing an existing model description.](img/ug33_import.png)
+Figure 33: Importing an existing model description.
+
+![Model description selection.](img/ug34_modeldesc.png)
+Figure 34: Model description selection.
+
+This import command creates an Architecture Structure Diagram describing
+the interface of an INTO-CPS block corresponding to the _modelDescription.xml_ file imported, cf. Figure 35. 
+
+![Result of model description import.](img/ug35_res_model_import.png)
+Figure 35: Result of model description import.
+
+
+## Connection diagram
+The SysML Connection diagram defines the components of the system and their connections. The internals of these block instances are created in the various modeling tools and exported as FMUs. The modeling tools Overture, 20-sim and OpenModelica support importing the interface definition (ports) of the blocks in the Connection diagram by importing a (FMI) _modelDescription.xml_ file containing the block name and its interface definition.
+
+Once you have created several SysML blocks , either from scratch or by importing _modelDescription.xml_ files, you must eventually connect instances of them in an INTO-CPS Connection Diagram. To create an INTO-CPS Connection diagram, as for an INTO-CPS Architecture Structure Diagram, right click on a _Package_ element, then in the INTO-CPS entry choose _Connection Diagram_, as shown in Figure 36.
+
+![ Creating a Connection diagram.](img/ug36_new_connection_dia.png)
+Figure 36: Creating a Connection diagram.
+
+
+
+
+Figure 37 shows the result of creating such a diagram.
+
+![Unpopulated Connection diagram.](img/ug37_empty_connection_dia.png)
+Figure 37: Unpopulated Connection diagram.
+
+Once you have created all desired block instances and their ports by using the dedicated command in
+the Connection Diagram palette, you will be able to model their connections
+by using the connector creation command (Figure 38).
+
+![Populated Connection diagram.](img/ug38_full_connection_dia.png)
+Figure 38: Populated Connection diagram.
+
+
+At this point your blocks have been defined and the connections have been set. The next step is
+to simulate your multi-model using the INTO-CPS Application. For that you
+must first generate a configuration file from your Connection diagram. Select
+the top element in the desired Connection diagram, right click on it and in
+the INTO-CPS entry choose Generate configuration, as shown in Figure 39.
+
+In the final step, choose a relevant block instance defining the interconnections of simulators and click on Generate. This will create a configuraiton json file for Maestro engine.
+
+![Generating a configuration file for Maestro](img/ug39_gen_config.png)
+Figure 39: Generating a configuration file.
+
+## Exporting FMI modelDescription.xml
+
+Once you finished modelling the system components with Architecture Structure Diagram (ASD) you may export the SysML block as _modelDescription.xml_ for FMU packaging.
+
+Follow these steps to export a modelDescription.xml file from Modelio:
+1. In Modelio, right-click on the model block in the tree.
+2. Select INTO-CPS → Generate Model Description (see Figure 40).
+3. Choose a file name containing the text _modelDescription.xml_ and click Export.
+
+![Exporting a modelDescription.xml file.](img/ug40_export_model.png)
+Figure 40: Exporting a modelDescription.xml file.
+
+# TODO: DSE Modelling
+