PHENOM Portal Knowledgebase - User contributions [en]

Export Models

2026-04-27T17:32:32Z

Chris:

This article is an abridged combination of [[Projects and Models Management]] and [[Data Model Generation]] intended to help users export their models from PHENOM.

== Select the Model ==
The unabridged article can be found here: [[Projects and Models Management#Projects Management]].

# Left-Click the Manage Models button. [[File:Phenom navigation bar 5.png|76px|alt=Manage Models mode button|Manage Models mode button]]
# Find the desired project in the project listing. [[File:Manage Models Project Listing.png|300px|alt=List of User's Projects]]
# Right-click on the project and click "Switch" to activate that project. [[File:Phenom-manage-switch-project.png|300px|alt=PHENOM Header]]
# Verify the intended model is active in the PHENOM header. [[File:Phenom-header-current-model-and-user.png|300px|alt=PHENOM Header]]

== Export the Data Model ==
The unabridged article can be found here: [[Data Model Generation]].

* Left-Click the Generate Mode button. [[File:Phenom navigation bar 4.png|76px|alt=Generate]]

* Ensure the following selections:
** '''Filter By:''' None

=== Generate a FACE Model ===
This will produce the canonical form of your model containing only official FACE model content. This format is compatible with other modeling tools.

* Ensure the following selections:
** '''Export Type:''' FACE (.face)
** '''Export CDM Queries:''' unchecked
** '''Export LDM Queries:''' unchecked
** '''Recover Retention Artifacts:''' unchecked
** '''Exclude Deprecated Content:''' CHECKED
** '''FACE Version:''' 3.1/3.2 (Latest Version Recommended)
* Left-Click the GENERATE button and wait for PHENOM to generate your model. The download will start automatically.

=== Generate a Skayl Model ===
The Skayl model format is a proprietary format that captures additional model content not fully specified by the FACE Technical Standard. This format is recommended if you need to capture Integration Model content or if you plan to load the model into PHENOM again at some point in the future.

* Ensure the following selections:
** '''Export Type:''' Skayl (.skayl)
** '''Exclude Deprecated Content:''' CHECKED

Export Models

2026-04-27T15:07:20Z

Chris: Created page with "This article is an abridged combination of Projects and Models Management and Data Model Generation intended to help users export their models from PHENOM. == Select the Model == The unabridged article can be found here: Projects and Models Management#Projects Management. # Left-Click the Manage Models button. Manage Models mode button # Find the desired project in the project lis..."

File:Phenom-header-current-model-and-user.png

2026-04-27T13:35:26Z

Chris: Chris uploaded a new version of File:Phenom-header-current-model-and-user.png

Current User and Model Display in Header

File:Manage Models Project Listing.png

2026-04-27T13:26:21Z

Chris:

This is a sample listing of projects in the Manage Models mode of PHENOM.

How-To Articles

2026-04-24T15:32:48Z

Chris:

#[[Login]]
#[[Dashboard]]
#[[Search Bar]]
#[[User Settings]]
#[[Basic Navigation]]
#[[Data Modeling]]
#[[Integration Modeling]]
#[[Generate]]
#[[Manage Models]]
----
#<li value="10"> [[Export Models]] </li>

Integrate Applications with PHENOM & CinC

2026-01-20T19:46:06Z

Chris:

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution. If you need help installing WSL, please follow [https://learn.microsoft.com/en-us/windows/wsl/install this link].}}

 

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [{{filepath:Robot_model_with_integration_model.skayl}} Download Robot_model_with_integration_model.skayl file]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (this was also tested with v2.2.1, v2.2.3 and v2.3.1)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
apt install unzip
</pre>

Some users have reported the need for slightly different commands. In some cases, they needed to install <code>sudo</code> which was needed to run <code>cmake</code>. If <code>apt install</code> does not work, you make need to use <code>apt-get install</code>. If the build fails, you may also need to run<code>apt install build-essential</code>.

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

== Build CinC ==
Return to the main cinc folder <code>cinc-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/Robot_Demo/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-20T19:28:20Z

Chris:

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [{{filepath:Robot_model_with_integration_model.skayl}} Download Robot_model_with_integration_model.skayl file]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3 and v2.3.1)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
apt install unzip
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

== Build CinC ==
Return to the main cinc folder <code>cinc-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/Robot_Demo/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-20T19:27:03Z

Chris:

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

2.
[{{filepath:Robot_model_with_integration_model.skayl}} Download the .skayl file]

3.
[[Special:FilePath/Robot_model_with_integration_model.skayl|Download the .skayl file]]

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3 and v2.3.1)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
apt install unzip
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

== Build CinC ==
Return to the main cinc folder <code>cinc-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/Robot_Demo/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-20T19:20:10Z

Chris:

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3 and v2.3.1)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
apt install unzip
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

== Build CinC ==
Return to the main cinc folder <code>cinc-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/Robot_Demo/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-19T22:04:13Z

Chris:

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
apt install unzip
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

== Build CinC ==
Return to the main cinc folder <code>cinc-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/Robot_Demo/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

File:Robot model with integration model.skayl

2026-01-19T22:02:44Z

Chris: Chris uploaded a new version of File:Robot model with integration model.skayl

Integrate Applications with PHENOM & CinC

2026-01-19T21:47:52Z

Chris:

'''DRAFT DRAFT DRAFT'''
This page has not yet been tested.

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
apt install unzip
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/Robot_Demo/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-19T20:14:28Z

Chris:

'''DRAFT DRAFT DRAFT'''
This page has not yet been tested.

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
apt install unzip
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

If unzip is not installed, run <code>sudo apt install unzip</code>.

== Install Pthread4W (Pthreads for Windows) ==
Obtain a copy of Pthreads4W here: https://github.com/jwinarske/pthreads4w

Unzip the pthreads file and copy the <code>pthreads4w-cmake</code> directory into the <code>cinc-2.2.3</code> directory.

Ensure the tools to build pthreads are installed:

<pre>
sudo apt install automake libtool mingw-w64
</pre>

Then build pthreads from the pthreads folder:

<pre>
autoheader
autoconf
mkdir -p build-win64 && cd build-win64
../configure --host=x86_64-w64-mingw32 --prefix="$PWD/install"
make clean GC
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/DemoMain/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-19T20:13:00Z

Chris: /* Prepare the Environment */

'''DRAFT DRAFT DRAFT'''
This page has not yet been tested.

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt update

apt install make
apt install g++
apt install cmake
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

If unzip is not installed, run <code>sudo apt install unzip</code>.

== Install Pthread4W (Pthreads for Windows) ==
Obtain a copy of Pthreads4W here: https://github.com/jwinarske/pthreads4w

Unzip the pthreads file and copy the <code>pthreads4w-cmake</code> directory into the <code>cinc-2.2.3</code> directory.

Ensure the tools to build pthreads are installed:

<pre>
sudo apt install automake libtool mingw-w64
</pre>

Then build pthreads from the pthreads folder:

<pre>
autoheader
autoconf
mkdir -p build-win64 && cd build-win64
../configure --host=x86_64-w64-mingw32 --prefix="$PWD/install"
make clean GC
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/DemoMain/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

File:Generate cinc select mains and uops.png

2026-01-19T19:47:06Z

Chris: Chris uploaded a new version of File:Generate cinc select mains and uops.png

Integrate Applications with PHENOM & CinC

2026-01-19T19:46:43Z

Chris: /* Export a CinC Package */

'''DRAFT DRAFT DRAFT'''
This page has not yet been tested.

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
In PHENOM, click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt install make
apt install g++
apt install cmake
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

If unzip is not installed, run <code>sudo apt install unzip</code>.

== Install Pthread4W (Pthreads for Windows) ==
Obtain a copy of Pthreads4W here: https://github.com/jwinarske/pthreads4w

Unzip the pthreads file and copy the <code>pthreads4w-cmake</code> directory into the <code>cinc-2.2.3</code> directory.

Ensure the tools to build pthreads are installed:

<pre>
sudo apt install automake libtool mingw-w64
</pre>

Then build pthreads from the pthreads folder:

<pre>
autoheader
autoconf
mkdir -p build-win64 && cd build-win64
../configure --host=x86_64-w64-mingw32 --prefix="$PWD/install"
make clean GC
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/DemoMain/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-19T19:41:25Z

Chris: /* Preparing PHENOM */

'''DRAFT DRAFT DRAFT'''
This page has not yet been tested.

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

Load this model into a new project in PHENOM. If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
Log into PHENOM and click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt install make
apt install g++
apt install cmake
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

If unzip is not installed, run <code>sudo apt install unzip</code>.

== Install Pthread4W (Pthreads for Windows) ==
Obtain a copy of Pthreads4W here: https://github.com/jwinarske/pthreads4w

Unzip the pthreads file and copy the <code>pthreads4w-cmake</code> directory into the <code>cinc-2.2.3</code> directory.

Ensure the tools to build pthreads are installed:

<pre>
sudo apt install automake libtool mingw-w64
</pre>

Then build pthreads from the pthreads folder:

<pre>
autoheader
autoconf
mkdir -p build-win64 && cd build-win64
../configure --host=x86_64-w64-mingw32 --prefix="$PWD/install"
make clean GC
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/DemoMain/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-19T19:40:48Z

Chris: /* Preparing PHENOM */

'''DRAFT DRAFT DRAFT'''
This page has not yet been tested.

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications, enabling them to communicate with each other. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
Log into PHENOM and click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt install make
apt install g++
apt install cmake
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

If unzip is not installed, run <code>sudo apt install unzip</code>.

== Install Pthread4W (Pthreads for Windows) ==
Obtain a copy of Pthreads4W here: https://github.com/jwinarske/pthreads4w

Unzip the pthreads file and copy the <code>pthreads4w-cmake</code> directory into the <code>cinc-2.2.3</code> directory.

Ensure the tools to build pthreads are installed:

<pre>
sudo apt install automake libtool mingw-w64
</pre>

Then build pthreads from the pthreads folder:

<pre>
autoheader
autoconf
mkdir -p build-win64 && cd build-win64
../configure --host=x86_64-w64-mingw32 --prefix="$PWD/install"
make clean GC
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/DemoMain/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-16T19:25:32Z

Chris:

'''DRAFT DRAFT DRAFT'''
This page has not yet been tested.

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
Log into PHENOM and click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt install make
apt install g++
apt install cmake
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

If unzip is not installed, run <code>sudo apt install unzip</code>.

== Install Pthread4W (Pthreads for Windows) ==
Obtain a copy of Pthreads4W here: https://github.com/jwinarske/pthreads4w

Unzip the pthreads file and copy the <code>pthreads4w-cmake</code> directory into the <code>cinc-2.2.3</code> directory.

Ensure the tools to build pthreads are installed:

<pre>
sudo apt install automake libtool mingw-w64
</pre>

Then build pthreads from the pthreads folder:

<pre>
autoheader
autoconf
mkdir -p build-win64 && cd build-win64
../configure --host=x86_64-w64-mingw32 --prefix="$PWD/install"
make clean GC
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/DemoMain/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

Integrate Applications with PHENOM & CinC

2026-01-16T19:24:57Z

Chris:

This tutorial will walk a user through the compilation and execution of a CinC-based application. It builds upon other tutorials in PHENOM. As such, it uses the same principles as [[Integration Model to CinC Generation]], but the content is different.

{{Info|heading=Windows Subsystem for Linux | 1=This tutorial is written to use Windows Subsystem for Linux (WSL 2) with a Ubuntu distribution.}}

==Preparing PHENOM==
In this tutorial, you will integrate two software applications. For the sake of simplicity, they will be integrated into a single executable. This will allow you to see the result of the integration by running a single file. This tutorial uses the Integration Model as shown in a previous tutorial.

Start by downloading this data model: [[File:robot_model_with_integration_model.skayl]]

{{Info|heading=Skayl File | 1=The FACE Technical Standard only defines the elements of an integration model. The details of each element are left to integrators. As a result, such details are not effectively stored in a .face model. A .skayl file is provided here to maintain this information.}}

If you need help loading the project file, please view this tutorial: [[Creating a Project from an Existing Model]].

== Export a CinC Package ==
Log into PHENOM and click on the GENERATE icon in the vertical bar on the left-hand side of the screen.

[[File:Phenom navigation bar 4.png|thumb|none]]

Select the CINC tab.

[[File:generate_menu_cinc_selected.png|thumb|none]]

Please make the following choices:
* '''CinC Artifact''' CinC
* '''CinC Version''' CinC 2.2.3 (note, other versions may work, this was tested with v2.2.3)
* '''FACE Version''' 3.0
* '''Language''' c++
* '''Override namespaces?''' Not Selected
* '''System Directory''' Test_System
* '''Include CinC Source?''' Selected
* '''Include Model files?''' Selected
* '''Selection Type''' Mains and UoPs

There is a prompt to '''Select your Mains and UoPs'''. Since the project was setup to have both applications in a single executable, both UoPs are listed under a single main. Ensure all three elements are selected, like this:

[[File:generate_cinc_select_mains_and_uops.png|thumb|none]]

Next, select a license. For this tutorial, you should choose '''Evaluation'''.

And finally, click '''GENERATE'''. PHENOM will start creating your source package and your browser will automatically download it once complete.

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Start your WSL instance, and ensure the proper packages are installed:
<pre>
apt install make
apt install g++
apt install cmake
</pre>

== Setup the Project ==
Unzip your CinC project in your user home (or other) directory. This will create a subdirectory called <code>cinc-2.2.3</code>.

From the wsl prompt, the command might look something like this:
<pre>
username@MachineName:~$ unzip /mnt/c/users/username/downloads/RobotModelProject_face3_cinc_<timestamp>.zip
</pre>

If unzip is not installed, run <code>sudo apt install unzip</code>.

== Install Pthread4W (Pthreads for Windows) ==
Obtain a copy of Pthreads4W here: https://github.com/jwinarske/pthreads4w

Unzip the pthreads file and copy the <code>pthreads4w-cmake</code> directory into the <code>cinc-2.2.3</code> directory.

Ensure the tools to build pthreads are installed:

<pre>
sudo apt install automake libtool mingw-w64
</pre>

Then build pthreads from the pthreads folder:

<pre>
autoheader
autoconf
mkdir -p build-win64 && cd build-win64
../configure --host=x86_64-w64-mingw32 --prefix="$PWD/install"
make clean GC
</pre>

== Build CinC ==
Return to the main cinc folder <code>cin-2.2.3</code> and run the following commands:

<pre>
cmake .
make
</pre>

== Configure the Logger ==
Although you can run your application at this point, it will produce no visible output.

Edit <code>Test_System/Config/DemoMain/TSS/TSS_TATS.xml</code> file.

Find the <code>logging_config</code> section of the config. If it does not exist, add it as the first block inside the 'cinc' configuration. The final result should look something like the following:

<pre>
<cinc>
<logging_config>
...
<logger type='uop' level='info' show_source='true' />
</logging_config>
...
</cinc>
</pre>

Where '...' represents other data that may be present.

== Run CinC ==
From the <code>cinc-2.2.3</code> directory, start your application using:
<pre>
./Test_System/Mains/Robot_Demo/Robot_Demo
</pre>

PHENOM has created a ''very basic'' implementation of each UoP. Transmitted data is populated with a constant value (typically pi). The logger indicated that information is being sent. The receiving application decodes the data type and prints the received value. If the application is printing out "3.14" along with some other information, it is working.

File:Robot model with integration model.skayl

2026-01-16T18:15:04Z

Chris:

Integrate Applications with PHENOM & CinC

2026-01-16T18:14:40Z

Chris:

File:Generate cinc select mains and uops.png

2026-01-16T16:36:39Z

Chris:

File:Generate menu cinc selected.png

2026-01-16T15:26:34Z

Chris:

Integrate Applications with PHENOM & CinC

2026-01-16T15:25:31Z

Chris:

Document Interfaces using PHENOM Portal

2026-01-16T15:05:09Z

Chris:

Documenting communication interfaces using good data modeling practices is easy in PHENOM Portal. This quick assignment will get you up and running documenting your own interfaces, creating valid and informative paths, and mapping your interface to others already documented.

==Preparing PHENOM==
In this tutorial, you will be documenting interfaces. However, in order for you to be able to do this, you need a data model that corresponds with this tutorial. Since there is already a tutorial for [[Developing an Entity Model]], this tutorial will start by loading a data model into PHENOM.

Start by downloading this data model: [[File:robot_model.face]]

Create a new project with this model. If you need any help, consult the following tutorial: [[Creating a Project from an Existing Model]].

==Prelude: Views, View-Characteristic, and Paths - What and Why==
In the task of documenting the Simple Operating Robot Data Interface, our main focus will be in [[View]]s. Views can be understood as the documentation of messages that the interface describes. A view documents a message interface, and each view-characteristic documents a single field of the message. More specifically, a view-characteristic contains information about the logical level of the message field (such as the measurement and unit being used) as well as information about the conceptual level of the message field (which entities and properties of entities are being talked about).

If you click on a view-characteristic, you will see that each has a name, an [[observable]], a measurement and axis (which further characterizes the observable), and a path documenting the entities and its context. Path development is the primary focus of this assignment - paths communicate the semantics of message fields in a machine understandable fashion. Engineer-written documentation for data coming in over the wire might indicate "Temperature of the main unit of an air system's propulsion system." which, though concise and informative, might not mean much to a machine. Paths allow us to write standardized descriptions of view-attributes, linking together different entities, such as engines, propulsion systems, and air vehicles, to create semantic, machine-readable documentation for the contents of a message. Below is an example view attribute describing the message field documented in the sentence above.

[[File:Phenom-tutorial-documenting-interface-example.png|thumb|none]]

Take a look at the path and see if you can connect it to the meaning intended by the engineer from the previous paragraph. Note that this page also captures how the measurement of this concept is expressed (i.e., measurement units and frame of reference). This information is used to construct the [[Logical Data Model]].

== Part 1: Documenting Robot Position Status==
The first message interface we have to implement is for communicating the '''Robot_Position_Status'''. We are given the following interface description:

{| class="wikitable"
|+ Robot_Position_Status - This message returns the position information of the robot.
|-
! Field ID !! Name & Description !! Unit !! Data Type
|-
| 1 || '''Robot_Id''' An alphanumeric string indicating the unique identifier of the robot system. || UTF-8 || String
|-
| 2 || '''Latitude''' The WGS-84 latitude value. || Radians || Double
|-
| 3 || '''Longitude''' The WGS-84 longitude value. || Radians || Double
|-
| 4 || '''Altitude''' The altitude value expressed in MSL. || Meters || Float
|}

Before documenting the message, take a look at the entity which this message is meant to describe. In the model we are using, the closest entity is Robot. Once you are logged into PHENOM, make sure that you click on the DATA MODELING button in the left-hand navigation panel. Then, type 'robot' into the search bar on top of Phenom's NavTree and bring up the page describing Robot. You will see that this entity is composed of a few attributes, some of them are [[observable]]s while another is an [[entity]].

Let's start the documentation by clicking the 'Create' button at the top left of the page and choosing to create a new view.

[[File:Phenom-datamodeling-create-view.png|frame|none]]

Give your view a name and a description following the information in the table at the top of this section and click save.

[[File:Phenom-datamodeling-view-save.png|frame|none]]

Once saved, you can find your new view in the tree by searching for it or opening its parent package. NOTE: PHENOM creates new views in the PhenomViews package. However, you may drag the elements into locations of your choosing (so long as they are valid).

Now, we can add an attribute to the view to describe the first field of the message - Robot_ID. To start, click on the CREATE button in the Attributes pane.

[[File:Phenom-datamodeling-view-create-attribute.png|frame|none]]

Fill in the View Attribute field with its name. The table indicates this should be: ''Robot_Id''

Given the name and description from the table, it is not hard to think that the best observable for it is [[Identifier]]. Selected that as our [[observable]], then choose a measurement that will likely best fulfill the id being a string - I chose UniqueID_UUID_Text_Meas.

[[File:Phenom-datamodeling-view-attribute-choose-obs-and-meas.png|frame|none]]

The next step is ''slightly'' more complicated. Originally, in PHENOM you could simply select any primitive type, and PHENOM would generate the appropriate results. Unfortunately, this leads to a proliferation of platform data types and users wanted us to provide a little more control for platform type reuse.

This leads to two options. First, you can create a new platform type. This is absolutely necessary when working with a new model. Once some platform types have already been created, the second option will allow you to reuse and existing platform type.

===Creating a Platform Type===
[[File:Phenom-datamodeling-view-attribute-create-platform-type.png|frame|none]]

===Select a Platform Type===

[[Category:UserGuide|0043_Document_Interfaces_using_PHENOM_Portal]]

Creating a Project from an Existing Model

2026-01-16T15:03:42Z

Chris: Created page with "This page will explain how to create a new Project by uploading the file from your local system. ===Switch to Manage Mode=== All model management functions are performed in the Manage Models section of PHENOM. After logging in, please click on the Manage Models icon. none ===Create a New Project=== It is possible to upload new content and create a new project all at once! To start, click on the ''Creat..."

This page will explain how to create a new Project by uploading the file from your local system.

===Switch to Manage Mode===
All model management functions are performed in the [[Manage|Manage Models]] section of PHENOM. After logging in, please click on the [[Manage|Manage Models]] icon.

[[File:Phenom navigation bar 5.png|thumb|none]]

===Create a New Project===
It is possible to upload new content and create a new project all at once! To start, click on the ''Create New Project'' button.

[[File:Phenom-manage-create-new-project.png|frame|none]]

===Select Models===
Once you click the button, the following screen should appear to the right of the Project listing.

[[File:Phenom-manage-create-new-project-select-models.png|frame|none]]

For the Project Name, please use a valid identifier.

You may leave Description blank. This field is intended for you to capture notes about the project (or model) and how it will be used.

In the bottom-left of this display, there is a list of existing models. This is used to add ''existing'' models to the new project. Ignore this for now.

In the bottom-right, click on ''Import FACE model''. This feature will allow you to upload .face and .skayl files alike. This button will add a model entry as follows:

[[File:Phenom-manage-create-new-project-load-model.png|frame|none]]

For the Model Name (the first text field), please enter a valid identifier.

As before, Description can be left blank.

Click on '''Select files...''' and a file chooser will appear. Navigate to your local data model file and choose that file. PHENOM will immediately start uploading the file. While the file is uploading and being preprocessed, the following status will appear:

[[File:Phenom-manage-create-new-project-model-loading.png|frame|none]]

Once the file has successfully transferred, PHENOM will show the file uploaded successfully with a green indicator.

[[File:Phenom-manage-create-new-project-model-loaded-successfully.png|frame|none]]

In the event of an error (e.g., invalid file type or invalid model), PHENOM will display an error as follows:

[[File:Phenom-manage-create-new-project-model-load-error.png|frame|none]]

Once the file has been successfully uploaded, click on the SAVE button.

[[File:Phenom-manage-create-new-project-save.png|frame|none]]

===Switch to New Model===
After saving the model, it will appear in the project browser. Simply '''right-click''' on the new project and choose Switch. This will load the new project and you are able to start operating on this content.

[[File:Phenom-manage-switch-project.png|frame|none]]

You can verify that you have switched to the new project by looking at the top of your PHENOM display. The current project is displayed beside your username.

[[File:Phenom-header-current-model-and-user.png|frame|none]]

File:Robot model.face

2026-01-15T19:02:21Z

Chris: Chris uploaded a new version of File:Robot model.face

== Summary ==
Data Model for Documentation Tutorial

Integrate Applications with PHENOM & CinC

2026-01-15T13:37:51Z

Chris: Created page with "This tutorial will walk a user through the compilation and execution of a CinC-based application. The CinC compilation portion of this tutorial is done using WSL (Windows Subsystem for Linux 2). == Create a Data Model == A UoP (Unit of Portability) represents your application. It defines all the inputs and outputs of the application by associating the data types (the queries and views defined in the data model) with the UoP. Start by creating a UoP. CREATE >> INT..."

This tutorial will walk a user through the compilation and execution of a CinC-based application.

The CinC compilation portion of this tutorial is done using WSL (Windows Subsystem for Linux 2).

== Create a Data Model ==

A UoP (Unit of Portability) represents your application. It defines all the inputs and outputs of the application by associating the data types (the queries and views defined in the data model) with the UoP.

Start by creating a UoP. CREATE >> INTEGRATION >> UOP

== Create an Integration Model ==
'''TODO'''

== Prepare the Environment ==
In your Windows user folder (typically C:\Users\<username>), create (or edit) the <code>.wslconfig</code> file.

Make sure the file contains the following entries:

<pre>
[wsl2]
networkingMode=mirrored

[experimental]
hostAddressLoopback=true
</pre>

Tutorials

2026-01-14T20:56:42Z

Chris: /* Exercises */

These hands-on tutorials walk users through different exercises to learn different aspects of PHENOM.

==Sample Workflows==
* [[Integration Model to CinC Generation]]

==Exercises==
* [[Developing an Entity Model]]
* [[Document Interfaces using PHENOM Portal]]
* [[Integrate Applications with PHENOM & CinC]]

==Video Tutorials==
* [https://youtu.be/DLnrkxV-CyQ Introduction & Navigation]
* [https://youtu.be/sZw5jo3bnuE Importing Data Models]
* [https://youtu.be/b7g0xgm5_64 Sharing Data Models]
* [https://youtu.be/DwyibQqIsMQ Using Navigation Mode]
* [https://youtu.be/JLOMXk3jIEM The Diagram Tool]
* [https://youtu.be/nTfelA07Nzw Configuration Management]
* [https://youtu.be/J_Poq7v5_rE Subscription & User Management]
* [https://youtu.be/3MVA5TNSouM Expert Mode]
* [https://youtu.be/Fe-9O-T8c-g Tagging]

[[Category:UserGuide|0041_Tutorials]]

Integration Model to CinC Generation

2026-01-13T17:50:59Z

Chris:

This sample workflow will lead the user to generate FACE 3 CinC after creating necessary Mains, UoP Instances, and UoPs.

== Create a UoP ==
A UoP (Unit of Portability) represents your application. It defines all the inputs and outputs of the application by associating the data types (the queries and views defined in the data model) with the UoP.

Start by creating a UoP. CREATE >> INTEGRATION >> UOP

Enter an appropriate name for the UoP and choose a parent package.

After description, there are three drop down boxes. These are options specified by the FACE Technical Standard. At this point, you can choose any value. However, you may need to choose specific values when you run the UoP through the conformance test suite. See [[FACE UoP Options]] for more details.

'''Message Ports / Connections'''
In the data model, the views (queries) define the data types that are ultimately sent and received by the UoP (applications). Click "+ Add New Message Port" to add the corresponding data type to this application.
* '''Name ''' Enter a name for the message port
* '''Message Pattern''' This describes the general way messages are transmitted and works in conjunction with the Exchange Type (message direction).
** '''Publish/Subscribe''' Publish/Subscribe indicates the messages will be (effectively) streamed.
** '''Client''' indicate that some other pattern will be used and this message port will play act as a client
** '''Server''' indicate that some other pattern will be used and this message port will play act as a server
* '''Exchange Type''' Indicates if the data will be sent or received.
* '''Message Type''' Select the view (query) corresponding to the data that will be sent/received.
* '''Synchronization''' Indicates if the application blocks when sending or awaiting data.
* '''Communication Style''' Indicates if the application sends a single message or manages a queue of messages
* '''Period (s)''' The period (in seconds) indicates the rate the message should be sent/received

For this first demonstration, choose:
* ''Publish/Subscribe'' for the messaging pattern
* ''Outbound'' for Exchange Type

Click SAVE (near the upper right).

Now, run through all the steps again to create a complementary UoP. Make sure you choose the same Message Type, but this time, choose ''' ''Inbound'' ''' for the Exchange Type.

[[File:Generate_-_CreateUoP.png|border|800x800px]]

== Create a UoP Instance ==
Since UoPs can be used in many different applications, UoP Instances are used to explicitly connect a UoP to an application.

A new UoP Instance can be created by selecting the corresponding option in the CREATE >> INTEGRATION >> UOP INSTANCE.

After providing an appropriate name, select the UoP that corresponds to this instance. Click SAVE near the upper right corner.

Repeat this process for the complementary UoP that you created in the previous section.

[[File:Generate_-_CreateUoPInstance2.png|border|800x800px]]

== Create an Integration Context ==
The Integration Context is a visual diagram of the interactions between a UoP and the configurable elements of CinC.

[[File:Generate - CreateContext.png|none|thumb|800px]]

Add UoP Instances that you created to the context.
* Find the UoP Instances in the navigation tree and select it
* Drag it onto the context.

At this point, the two UoP (instances) exist, but they do not know how to communicate with each other. In this simplest of examples where the two UoPs are communicating using the same message, they can easily be integrated by using a Transporter block.

* In the toolbar on the left side of the diagram find and select the transporter block
* Drag the transporter block onto the diagram.

A Transporter is a represents where the flow of data is occurring. However, it is a somewhat generic concept that needs further configuration. This is where you select the ''transport protocol''.

* With the transporter block selected, on the right side find the Transport Channel control and click on the '+' to add a new channel
* Give the channel a name and click the save icon.
* Once the save completes, click on the transport channel drop down and select the name of the channel you just created.

Now you are ready to connect the blocks to each other.

* Select the first UoP Instance block in the diagram (this should be the "outbound" application)
* Click on the up arrow at the upper right corner of the block and drag it to the transporter block
* A popup dialog will allow you to select the UoP port to connect to the transporter, select the port from the drop down list and click on save (in this case, there is only one)
* Select the Transporter block in the diagram
* Click on the up arrow at the upper right corner of the transporter block and drag it to the second UoP Instance (this should be the "inbound" application)

Up to this point, we have relied on the SAVE button to persist most of our changes. However, diagrams work a little differently. In order to persist diagrammed changes, you need to commit the changes.

* Click the Commit button under the heading Model on the diagram tool bar. This saves the changes to the Integration Model (IM) elements but does NOT save the diagram.
* Now, save the diagram. Click the middle disk icon under diagram in order to save the layout of the elements in the diagram. This saves the layout of the items in the diagram but does NOT save changes to the Integration or Deployment models that may have been made while editing the diagram elements.

== Create a Main ==
The Main Program represents the executable program containing one (or more) UoPs and CinC.

A new Main Program can be created by selecting the corresponding option in the CREATE >> DEPLOYMENT.

After setting an appropriate name, 'the most important thing' is to add your UoP Instances to the executable. Look halfway down the page and there is a '''Contains UOP Instances''' heading with a list of UoP Instances. Use the drop down box at the bottom of that section to add your UoP Instances.

Click SAVE near the upper right corner.

[[File:Generate_-_CreateMainProgram2.png|none|thumb|800x800px]]

== Add a TPM ==
The transport protocol module is responsible for the serialization and deserialization of messages and their transport from one TPM to another or another system.

'''This step is optional as PHENOM will generate a UDP TPM by default.'''

[[File:Generate - MainCreateTPM2.png|thumb|none|800px]]
# Within the Main detail page, after saving the main, click on the Create TPM button.
# Give the TPM a name ('tpm' is fine).
# Click the save button.
# Commit the changes to the main by clicking the disk icon in the upper right.

== Generate CinC ==
This is the step where you will actually be transforming your model into a downloadable source code package.

* Open the 'Generate' section and click on the CinC submenu.
# Select 'CinC' as the artifact.
# Select the version of CinC you would like to generate
# Select include CinC Source and choose Yes.
# Select the Main and UoP Instances for the context we created above and make sure they are both checked
# Select the appropriate license.
# Click on the Generate button and a zip file will be created. The .zip file will contain the CinC source, the data modeled FACE types used by the UoP and the CinC configuration files. Save the file and extract the generated code.

[[File:Generate_-_CinC.png|none|thumb|800x800px]]

[[Category:UserGuide|0044_Integration_Model_to_CinC_Generation]]

Integration Model to CinC Generation

2026-01-13T16:33:32Z

Chris:

This sample workflow will lead the user to generate FACE 3 CinC after creating necessary Mains, UoP Instances, and UoPs.

== Create a UoP ==
A UoP (Unit of Portability) represents your application. It defines all the inputs and outputs of the application by associating the data types (the queries and views defined in the data model) with the UoP.

Start by creating a UoP. CREATE >> INTEGRATION >> UOP

Enter an appropriate name for the UoP and choose a parent package.

After description, there are three drop down boxes. These are options specified by the FACE Technical Standard. At this point, you can choose any value. However, you may need to choose specific values when you run the UoP through the conformance test suite. See [[FACE UoP Options]] for more details.

'''Message Ports / Connections'''
In the data model, the views (queries) define the data types that are ultimately sent and received by the UoP (applications). Click "+ Add New Message Port" to add the corresponding data type to this application.
* '''Name ''' Enter a name for the message port
* '''Message Pattern''' This describes the general way messages are transmitted and works in conjunction with the Exchange Type (message direction).
** '''Publish/Subscribe''' Publish/Subscribe indicates the messages will be (effectively) streamed.
** '''Client''' indicate that some other pattern will be used and this message port will play act as a client
** '''Server''' indicate that some other pattern will be used and this message port will play act as a server
* '''Exchange Type''' Indicates if the data will be sent or received.
* '''Message Type''' Select the view (query) corresponding to the data that will be sent/received.
* '''Synchronization''' Indicates if the application blocks when sending or awaiting data.
* '''Communication Style''' Indicates if the application sends a single message or manages a queue of messages
* '''Period (s)''' The period (in seconds) indicates the rate the message should be sent/received

For this first demonstration, choose:
* ''Publish/Subscribe'' for the messaging pattern
* ''Outbound'' for Exchange Type

Click SAVE (near the upper right).

Now, run through all the steps again to create a complementary UoP. Make sure you choose the same Message Type, but this time, choose ''' ''Inbound'' ''' for the Exchange Type.

[[File:Generate_-_CreateUoP.png|border|800x800px]]

== Create a UoP Instance ==
Once the user has created their UoP it is now time to create the UoP Instance that will be used in CinC generation. This UoP Instance is going to be very important for later steps.

Similarly, new UoP Instance can be created by selecting the corresponding option in the 'Create>Integration' dropdown and then saving after inputting the required data .
[[File:Generate_-_CreateUoPInstance2.png|border|800x800px]]

== Create a Context ==
The context is a visual diagram of the interactions between a UoP and the configurable elements of CinC.
[[File:Generate - CreateContext.png|none|thumb|800px]]
# Add UoP Instance to the context.
## Find the UoP Instance in the navigation tree and select it
## Drag it onto the context.
# Add a Transporter to the context.
## In the horizontal toolbar on the left side of the diagram find and select the transporter block
## Drag the transporter block onto the diagram.
# Create a Transport Channel
## With the transporter block selected, on the right side find the Transport Channel control and click on the '+' to add a new channel
## Give the channel a name and click the save icon.
## Once the save completes, click on the transport channel drop down and select the name of the channel you just created.
# Connect the blocks
##Select the Uop Instance block in the diagram
## click on the up arrow at the upper right corner of the block and drag it over to the transporter block.
## A popup dialog will allow you to select the UoP port to connect to the transporter, select the port from the drop down list and click on save.
#Commit the changes.
##Click the Commit button under the heading Model on the diagram tool bar. This saves the changes to the Integration Model (IM) elements but does NOT save the diagram.
# Save the diagram
##click the middle disk icon under diagram in order to save the layout of the elements in the diagram. This saves the layout of the items in the diagram but does NOT save changes to the Integration or Deployment models that may have been made while editing the diagram elements.

== Create a Main ==
The Main Program represents the executable program containing one (or more) UoPs and CinC.
#A new Main Program can be created by selecting the corresponding option in the 'Create>Deployment' dropdown and then saving after inputting the needed data including the UoP Instance.
[[File:Generate_-_CreateMainProgram2.png|none|thumb|800x800px]]

== Add a TPM ==
The transport protocol module is responsible for the serialization and deserialization of messages and their transport from one TPM to another or another system.

'''This step is optional as PHENOM will generate a UDP TPM by default.'''

[[File:Generate - MainCreateTPM2.png|thumb|none|800px]]
# Within the Main detail page, after saving the main, click on the Create TPM button.
# Give the TPM a name ('tpm' is fine).
# Click the save button.
# Commit the changes to the main by clicking the disk icon in the upper right.

== Generate CinC ==
# Next the user needs to open the 'Generate' section and click on the CinC submenu.
# The user should select 'CinC' as the artifact.
# Select the version of CinC you would like to generate
# Select include CinC Source and choose Yes.
# Select the Main and UoP Instances for the context we created above and make sure they are both checked
# Select the appropriate license.
# Click on the Generate button and a zip file will be created. The .zip file will contain the cinc source, the data modeled FACE types used by the UoP and the CinC configuration files. Save the file and extract the generated code.
[[File:Generate_-_CinC.png|none|thumb|800x800px]]

[[Category:UserGuide|0044_Integration_Model_to_CinC_Generation]]

Merge External Model

2025-12-12T14:52:44Z

Chris: Created page with "A merge external model operation imports nodes from an external model file into the current project. During this process, the system checks each incoming node’s globally unique identifier (GUID): * If the node’s ID does not already exist in the current project, the node is eligible to be added. * If the node’s ID is already present, the existing node in the project is preserved and the incoming one is ignored. The merge also verifies that each incoming node has a..."

A merge external model operation imports nodes from an external model file into the current project. During this process, the system checks each incoming node’s globally unique identifier (GUID):

* If the node’s ID does not already exist in the current project, the node is eligible to be added.
* If the node’s ID is already present, the existing node in the project is preserved and the incoming one is ignored.

The merge also verifies that each incoming node has a valid parent in the destination project. Any node that cannot be placed under an appropriate parent - even if it would otherwise qualify for merging - is excluded to maintain structural consistency. In order for a parent to be considered valid, the user must have (at least) write permissions (to the parent node) and the parent node must not be [[Projects and Models Management#Model Versions | published]].

== Overwrite Option ==
If the Overwrite option is enabled, the merge behaves more aggressively. For nodes that exist in both the source model and the destination project, the system compares their contents. When differences are found, the destination node is updated to match the version from the source model.

== Check for Name Collisions Option ==
The Check for Name Collisions option controls how the merge process handles situations where two different entities - identified by different GUIDs - share the same name.

When '''enabled''', the merge operation will fail if it encounters two distinct entities that use the same name. This safeguard ensures that no ambiguous or conflicting names are introduced into the project. (Entities with the same GUID and same name are not affected by this rule.)

When '''disabled''', the merge operation will complete even if name conflicts exist. In this mode, the system allows potentially overlapping names to coexist, and any required name adjustments must be resolved manually after the merge.

This setting is recommended when merging models from unrelated or independently developed sources, where naming overlaps are more likely.

FAQ

2025-10-23T12:21:46Z

Chris:

== How do I submit a ticket? ==
If you have an issue or a questions, you can email us at [http://mailto:support@phenomportal.com support@phenomportal.com]. We'll have you up and running as soon as possible.

== How can I share feedback & report bugs? ==
We welcome your feedback! If you've identified a bug, need help with user access, or have recommendations for future features, please email us at [http://mailto:support@phenomportal.com support@phenomportal.com].

== How often will new PHENOM features be released? ==
We’re constantly working to improve and extend PHENOM, both the software and the underlying data models and content. We'll always be making little tweaks to make things simpler for you, but of course, we have major new feature additions planned as well. Those improvements are released about every three weeks.

Your Dashboard lists the most recent updates made, and we send out emails when there is major update available.

Best of all, all software updates, enhancements, new modules as well as extensions to your data model are included in your licensing fee.

== Can I see all this content on one page? ==
A curated set of articles from the knowledgebase can be found here [[User's Guide (One Page)]].

User's Guide (One Page)

2025-10-23T12:19:39Z

Chris: Chris moved page Book to User's Guide (One Page) without leaving a redirect

==About PHENOM Portal==
{{:About PHENOM Portal}}

==Getting Started==
{{:Getting Started}}

==Login==
{{:Login}}

==Basic Navigation==
{{:Basic Navigation}}

==Dashboard==
{{:Dashboard}}

==Search Bar==
{{:Search Bar}}

==Data Modeling==
{{:Data Modeling}}

==Data Model Details==
{{:Data Model Details}}

==Entity and Association==
{{:Entity and Association}}

==View==
{{:View}}

==View Attribute==
{{:View Attribute}}

==Package==
{{:Package}}

==Observable==
{{:Observable}}

==Measurement==
{{:Measurement}}

==Enumerations==
{{:Enumerations}}

==Platform Type and Enumeration==
{{:Platform Type and Enumeration}}

==Constraint==
{{:Constraint}}

==Measurement System and Coordinate System==
{{:Measurement System and Coordinate System}}

==Reference Point==
{{:Reference Point}}

==Diagram==
{{:Diagram}}

==Healthcheck==
{{:Healthcheck}}

==Meridian Map==
{{:Meridian Map}}

==Semantic Matches==
{{:Semantic Matches}}

==View Trace==
{{:View Trace}}

==Import==
{{:Import}}

==Analytics==
{{:Analytics}}

==Integration Modeling==
{{:Integration Modeling}}

==Integration Model Details==
{{:Integration Model Details}}

==Service / UOP & Message Port==
{{:Service / UOP & Message Port}}

==Transport Channel==
{{:Transport Channel}}

==Integration Model Editor==
{{:Integration Model Editor}}

==Generate==
{{:Generate}}

==Data Model Generation=={{:Data Model Generation}}

==CinC Generation==
{{:CinC Generation}}

==Templates==
{{:Templates}}

==Manage==
{{:Manage}}

==Projects and Models Management==
{{:Projects and Models Management}}

==Push, Pull, and Approve Process==
{{:Push, Pull, and Approve Process}}

==Review Project==
{{:Review Project}}

==Permissions==
{{:Permissions}}

==Tutorials==
{{:Tutorials}}

==Developing an Entity Model==
{{:Developing an Entity Model}}

==Document Interfaces using PHENOM Portal==
{{:Document Interfaces using PHENOM Portal}}

==Integration Model to CinC Generation==
{{:Integration Model to CinC Generation}}

==Support==
{{:Support}}

User's Guide (One Page)

2025-10-22T20:44:08Z

Chris: Created page with "==About PHENOM Portal== {{:About PHENOM Portal}} ==Getting Started== {{:Getting Started}} ==Login== {{:Login}} ==Basic Navigation== {{:Basic Navigation}} ==Dashboard== {{:Dashboard}} ==Search Bar== {{:Search Bar}} ==Data Modeling== {{:Data Modeling}} ==Data Model Details== {{:Data Model Details}} ==Entity and Association== {{:Entity and Association}} ==View== {{:View}} ==View Attribute== {{:View Attribute}} ==Package== {{:Package}} ==Observable== {{:Observabl..."

View Attribute

2025-10-22T20:28:46Z

Chris:

A View Attribute can be also referred to as view characteristic or view field.

== Creating & Editing View Attributes ==
To create a new View Attribute, click the "Create" button in the Attributes section of a [[View]] details page:

[[File:Phenom-data model-details view attr create.png|1200px|border]]

[[File:Phenom-data model-details view attr new.png|1000px|border]]

A View Attribute must have:
* A unique and conformant name
* An [[Observable]]
* A [[Measurement]]
* A path

=== Name ===
The attribute's name must consist of letters, numbers, or underscores and start with a letter.

=== Observable/Measurement ===
The user can either start by selecting an Observable and then the Measurement - the Measurement list will be filtered to the Measurements realizing the selected Observable - or select the Measurement first which will automatically select the Observable the Measurement realizes.

[[File:Phenom-data model-details view attr obs meas.png|1000px|border]]

=== Platform Type ===
Once the Measurement is selected, the user needs to either create a new Platform Type or select an existing one by clicking "Select Platform Type"

[[File:Phenom-data model-details view attr new ptf type.png|1000px|border]]

[[File:Phenom-data model-details view attr select ptf type.png|1000px|border]]

=== Path ===
The final step in creating a View Attribute is to add a semantic path using the path builder. The path is built hop by hop, starting with the entity/association attribute typing the selected observable. Each hop must be committed by clicking the checkmark before being able to move to the next. The last selected hop can be removed by clicking the x next to the new hop box. The current path of the attribute is rendered under the Path section title.

[[File:Phenom-data model-details view attr path1.png|1000px|border]]

After committing a hop, if there are additional hops that can be added, they will appear in the dropdown list, otherwise the text "No Possible Options" will appear.

[[File:Phenom-data model-details view attr path2.png|1000px|border]]

[[File:Phenom-data model-details view attr path3.png|1000px|border]]

The circling arrow and the X next to the commit button respectively resets and cleans the path.

[[File:Phenom-data model-details view attr path4.png|1000px|border]]

=== Destructure Linkers ===
Destructure Linkers are available when a view attribute has a IDL Struct Platform Type. The option is present on the view attribute page.
[[File:IDLStruct in Attribute Page.png|frameless|1007x1007px]]

When enabling the Destructure Linker toggle, some additional options will pop up such as a Destructure Reference radio button and a option to create a new, or select an existing Destructure Linker. It's only possible to select a single IDL Composition as a Destructure Reference.

[[File:Destructure linker enabled.png|frameless|1017x1017px]]

After saving when selecting a Reference and a Linker, the parent view of the attribute will now update it's 'Query and Template Preview' to include the new Destructure Linker

[[File:Update Query and Template Preview.png|frameless|1013x1013px]]

== Creating & Editing Nesting View Attributes ==
To create a new Nesting View Attribute, click the "Add Nesting" button in the Attributes section of a View details page:

[[File:Phenom-data model-details nesting view attr create.png|1000px|border]]

A Nesting View Attribute must have:
* A unique and conformant name
* A View
* A path
* Be Privately Scoped or Foreign Reference

Nesting View Attributes are created and edited inline. Any new or updated Nesting View Attributes will be saved when the user clicks on the "Save" button either for the row or for the entire View.

A Nesting View Attribute must point to a view with a uniform projected characteristic. The foreign referenced Nesting View Attribute's uniform projected characteristic must match the type of the last hop of the perspective path used by any field that nests it.

A Nesting View Attribute can either be a "Foreign Reference" or a "Privately Scoped" attribute. If the Private checkbox is checked, then the attribute is marked as "Privately Scoped" otherwise, it is marked as "Foreign Reference". New Nesting View Attribute defaults to "Privately Scoped".

Note that when switching from a Nesting to a Composite View, the Path/Perspective attribute and the Private attribute are cleared on save.

[[Category:UserGuide|011_View_Attribute]]

Getting Started

2025-10-22T17:20:50Z

Chris:

== Welcome to PHENOM by Skayl! ==

If you're new to PHENOM, or if you haven't had your introductory training yet, this page can help get you oriented to some of the tools basic features. Click on the Getting Started link below to see a tree of links to instructions on beginning functionality within PHENOM, including login, settings, navigating and editing.

== Introductory Topics ==
* [[Login]]
* [[Dashboard]]
* [[Data Modeling]]
* [[Integration Modeling]]
* [[Generate]]
* [[Manage]]

[[Category:UserGuide|002_Getting_Started]]

About PHENOM Portal

2025-10-22T17:20:08Z

Chris:

= Not Just another Modeling Tool =
The Skayl team has been practicing this form of data modeling since 2011...before Skayl even existed. Our team worked together on a project developing the modeling technology as well as an initial model. After one particular model update cycle, a couple of million dollars worth of work was lost. A minor change in the model resulted in the need to reproduce a lot of work. To make matters worse, this could have been avoided with some specialized tooling. Thus the idea of PHENOM was born. At that moment, we committed to make sure this amount of loss would not occur again.

Skayl did not aspire to be a tool vendor. We developed the tool we needed to data model and decided to share it with others. PHENOM has continued to grow as our customer needs change.

== The Initial Release of PHENOM ==
The original PHENOM release was based on the idea of "one domain specific data model per server." Skayl envisioned hosting many different DSDMs for different purposes. One server would exist for the Aerospace and Defense community. Another server would exist for medical technology, etc. It wasn't long before users wanted to upload their own models and import their own content. Thus the tool (and our vision for us) started to evolve.

= Release Cycle =
We’re constantly working to improve and extend PHENOM, both the software and the underlying data models and content. We are always making little tweaks to make things simpler for you, but of course, we have major new feature additions planned as well.

Your Dashboard will list the most recent updates made, and we’ll send out emails when there is major update available. Of course, if you use the Skayl-hosted version of PHENOM, the updates will automatically appear the next time you login. If you are an enterprise user, your IT department will periodically update your PHENOM instance to the latest version.

[[Category:UserGuide|001_About_PHENOM_Portal]]

Support

2025-10-22T16:58:02Z

Chris:

==How Do I Submit a Ticket?==
Please email us at support@skayl.com. We'll have you up and running as soon as possible.

==How Can I Share Feedback & Report Bugs?==
We welcome your feedback! If you've identified a bug or have recommendations for future features, please email us at support@skayl.com.

Creating a Filtered Project

2025-10-22T16:50:16Z

Chris:

'''This Feature is Current Inactive.'''

In some instances, a user may wish to share only a small part of a project with another user, without burdening them with the entirety of it. If the user you are sharing with only needs access to a few views or a subset of the measurements available, this functionality can be utilized to build a new filtered project that maintains its model inheritance relationship with the initial project. Any changes made to this new project can be pushed up to the initial project, and any changes made in the initial project can be pulled down to the filtered project so long as the changes are to a non-filtered element.

== Create a new filtered project ==
In order to create a filtered project, follow these steps:
# Go to the Manage Models page in PHENOM
# Select the project that you would like to filter
# You will notice a "Create new filtered project" button appear at the top of the list
#:[[File:Phenom-manage-create filtered project.png|border]]
# Once you click that button, the right panel will load the creation form with two Nav Trees
#: [[File:Phenom-manage-new filtered project.png|600px|border]]
# In this panel, there are several options that make filtering your project easier
#* ''Project Name'': this is the name of your resulting filtered project. It defaults to the name of your initial project with "_filtered" added to the end.
#* ''New Project Starting State'': this allows you to choose the starting state of your project, either a full project from which you remove elements or an empty project to which you add elements.
#* ''Left Hand Nav Tree'': this is the Nav Tree that represents the initial project. In this Nav Tree, you'll find every element from the model.
#* ''Right Hand Nav Tree'': this is the Nav tree that represents your filtered project. This tree will change as you add and remove elements from the initial project.
#* ''Add Button'': this button will add the selected model elements from the Left Hand Nav Tree and all the elements that they depend on to the Right Hand Nav Tree.
#* ''Remove Button'': this button will remove the selected model elements from the Right Hand Nav Tree and all the elements that depend on them.
# Once you have used the options above to filter your project to your satisfaction, you can press the Save button in the top right corner. This will create a new project that contains only the elements in the Right Hand Nav Tree, but still inherits from the models in the initial project.

== Alter a filtered project ==
Should you not be satisfied with your filtering and wish to change it, you may press the alter filter button on the top right corner of the project details pane of the newly created project.
Please note this button is only available so long as no changes have been pushed from the filtered project and no other models have inherited from the models in the filtered project.
This button will launch the filtering dialog again, where you can follow the same steps until your model is filtered to your satisfaction.
[[File:Phenom-manage-alter filtered project.png|600px|border]]

Data Modeling

2025-10-22T16:07:37Z

Chris:

==[[Data Model Details]]==
The details tab is where most of the detailed model editing is done. Although selecting the [[details]] tab directly does very little, this is where the properties appear once an element has been selected from the [[NavTree]].

==[[Diagram]]==
Diagrams are a very easy way to visualize models and explore their connectivity. A modeling tool would not be complete without some means of building diagrams. While constructing PHENOM's diagramming engine, users expressed their desire for a "modeling scratchpad" capability. This concept allows users to build model content without immediately affecting the data model. This makes it possible to experiment with different modeling ideas without adding a bunch of intermediate content to the model. The new elements become official model content once they are "committed."

Beyond modeling new elements and patterns, the diagram tool can be used to build interface documentation. This functions oppositely from PHENOM's typical mode of documentation. Instead of start with the most specific details and then adding context, this view editing tool starts with the broadest context and narrows down to the most specific details. This approach is difficult to use unless you know the data model.

==[[Health Check|Healthcheck]]==
Rapidly check the overall health of your data model using PHENOM's Health Check. It runs 19 different tests against the model.

Some of the health checks provide tools to help users fix errors.

==[[Analytics]]==
These are tools that provide additional insight into the model. It can show the distribution of entities and attributes used in the documentation. This helps identify areas of the model where refactoring activities can provide the greatest benefit.

==[[Meridian Map]]==
The Meridian Map is a type of ribbon diagram that shows the semantic alignment of a collection of views. Drag up to 50 views into the Meridian Map, and it will quickly render the a graph showing all of the 100% semantic matches.

By default, this alignment works at the conceptual level. This means that a latitude position will map to a longitude position. In order to further filter using the measurement information, make sure that "Logical Matches Only" is selected.

==[[View Trace]]==
The View Trace tool allows users to map a set of views (one or more) to another set of views (one or more). Although the data model automates the View Trace process, there are times when it is necessary to map dissimilar semantics. View Trace is the primary mechanism for overriding semantic mappings.

==[[Import]]==
Although loading FACE XMI models (.face files) is the primary mechanism for importing bulk data into PHENOM, the import section has some helpful tools for importing data that may not conform to this default format.

PHENOM has the ability to import: [[Entity and Association| Entities]], [[Entity and Association| Associations]], [[View]]s, [[Platform Type and Enumeration|Enumerations]], [[Constraint]]s, and [[Platform Type and Enumeration|Platform Types]].

[[Category:UserGuide|003_Data_Modeling]]

Dashboard

2025-10-22T16:06:49Z

Chris:

PHENOM's Dashboard is the first screen users will see when they log in. The Dashboard communicates the latest general analytics regarding the core model, recent changes to the model, and the most recent as well as archived Release Notes, containing a summary of the latest features added to PHENOM. The dashboard also provides a series of Quick Links - these are common actions intended to help the novice user find what they need easily.

== Using the Dashboard ==
When you first log into PHENOM, you will see your personal dashboard. This section will show you the key elements of the dashboard.

Across the very top of your dashboard, you find your login name as well as the name of your current branch. Read more about [[Branches]]. Since PHENOM allows you to change branches and work in other models, this is a helpful tool so you can be sure that you are editing the branch of the model you expect.

[[File:Phenom dashboard 1.jpg|thumb|center|alt=This is a screenshot that highlights where the username and currently active project is shown.|Current User and Branch Identification]]

On the left-hand side, you will see the navigation links. This is where you can choose between the major functions of PHENOM.

NOTE: This interface is expected to change. While it may look different and the currently listed commands may be allocated to another place on the website, the function remains the same. Use this area to switch between the main modes of operation of the site.

[[File:Phenom dashboard 2.jpg|thumb|center]]

Across the top of the dashboard, you see the project overview. This is a live count of the number of entities, attributes, and views currently managed in your branch. The shapes, sizes and proportions of the regions in the overview can provide a high-level idea of model quality and how the model is currently used.

[[File:Phenom dashboard 3.jpg|thumb|center]]

The next section is a series of Quick Links. These are common actions that are commonly performed in PHENOM and is intended to help a novice user quickly navigate to the correct function.

[[File:Phenom dashboard 5.jpg|thumb|center]]

Finally, you see the notification area typically used to announce the features added in the latest release. When you log in, you can go here to find out what has changed since the last update of the software.

[[File:Phenom dashboard 4.jpg|thumb|center]]

[[Category:UserGuide|002_Dashboard]]

Login

2025-10-22T16:05:04Z

Chris:

PHENOM users will be prompted for a username and password upon login. Each user should have a unique username. If a user has set up Two-Factor Authentication previously, this authentication will be requested after the username and password is verified.

== Requesting an Account ==
To request a new user account to PHENOM:

# Contact your organization's PHENOM administrator and request access
or
# email INQUIRIES@SKAYL.COM
# Include your organization's name, your full name, your email address, phone number in the email

== Logging Into PHENOM ==
Login Using Username and Password

#Go to your PHENOM portal URL
#Enter your username
#Enter your password (of this is your first time logging in, enter the password provided to you. Once you are logged in, you can change your password in [[Settings]])

<gallery>
PHENOM_Login_Screenshot.png|Screenshot of PHENOM Portal Login Prompt
</gallery>

== Logging in with Two-Factor Authentication ==
Once you have set up Two-Factor Authentication, you will need access to your mobile device to login to your PHENOM account.

#At the Login prompt, enter your PHENOM username and password
#Upon successful password verification, PHENOM will request your Authenticator passcode
#Open the Authenticator app on your phone
#Under PHENOM, you will find the Authenticator passcode, enter this code into PHENOM
#You are now logged into PHENOM

== Requesting a New Password ==
To request a new password to PHENOM:

On the login page, click “request a new password”:

[[File:Phenom Password Request Step 1.png|none|none]]

Enter your username and click “Request Reset”:

[[File:Phenom Password Request Step 2.png|none|none]]

After a few minutes you should receive a password reset email. Copy paste the link into your web browser (if it redirects to the login page, copy paste the link and refresh the page again):

[[File:Phenom Password Request Step 3.png|none|none]]

Enter a new password, click “Reset Password”.

[[File:Phenom Password Request Step 4.png|none|none]]

Login with your username and new password.

[[File:PHENOM_Login_Screenshot.png|none|none]]

[[Category:UserGuide|001_Logging_In]]

Getting Started

2025-10-22T15:49:14Z

Chris:

User:Chris/Books/User's Guide

2025-10-20T19:31:08Z

Chris: Created page with "{{saved_book}} :Main Page User's Guide"

{{saved_book}}

:[[Main Page]]

[[Category:Books|User's Guide]]

Projects and Models Management

2025-09-24T20:51:29Z

Chris: /* Copy Project */

== Projects & Models 101 ==
A '''project''' in PHENOM is composed of one or more models which are loaded together into a workspace.
A '''model''' is a collection of nodes. A node can be an entity, an association, an observable, a view…
One objective of a project is to be:
* Independent
* Complete: reflect the reality to the best of its ability
* Compliant
* Valid (or at least "validatable ")
A model in and of itself might not constitute a complete, compliant, or even valid project as it might depend on entities inside other models, making it impossible to load independently. However, by combining several models in a project, they can form a complete, compliant, and valid model.

[[File:Phenom-manage-project model structure1.png|600px|border]]

The following diagram depicts how a model can be part of multiple projects.

[[File:Phenom-manage-project model structure2.png|600px|border]]

Once a project is loaded into PHENOM, the node contents of its constituent models can be added to as well as edited.

== Projects Management ==
When in PHENOM > Manage Models > Projects, the user can see the projects and models they have access to.

[[File:Phenom-manage-projects models list.png|500px|border]]

The project you are currently working on is displayed at the top of all the pages. Additionally, in the Manage Projects page, the active project is the expanded by default and has a different icon.

[[File:Phenom-manage-active project.png|600px|border]]

To create a project, the user can click on the + button in the Projects list and then select existing models, import new FACE models, or add new blank models.

[[File:Phenom-manage-new project.png|600px|border]]

There are three ways a user can have access to a project or a model:
* The user creates it
* The user uploads it
* The user is assigned permissions from an external user
The user will see, for each model, its inheritors and versions.

The user can easily switch between projects in the Projects Management page.

[[File:Phenom-manage-switch-project-2.png|border|800x800px]]

== Model Versions ==
In PHENOM, models maintain the content as well as the record of changes made to that content.

By default, each model has a "live" version. This is the version of the model which, when loaded in a project can be edited and amended.

When the user is satisfied with the current state of a model, they can publish it, thus creating a “static” version of that model. A published version of a model is a snapshot of its content at one point in time. It cannot be added to or edited but can still be included in a project, referenced by and depended upon by the contents of a different model.

In the example below, the model version FACE_SDM_306 and FACE_SDM_316 are a "published" version of the FACE_SDM model. While it can be shared with other users, included in a project, and referred to and depended upon by other models, it can never be edited. In the Model tree, all published models have their publication dates displayed for ease of use.

[[File:Phenom-manage-published model.png|600px|border]]

== Model Inheritance & Content Merging ==
The same model can be loaded as a part of several different projects. However, the users of those projects will not be able to edit the content of the model simultaneously.
When a user chooses to include in a project a model which is already a part of a different project, a "child" model will be created. This inheriting or "child" model is not a different version of a model, but rather its own model which inherits some portion of its content.
At first, the inheriting and the parent models are identical but as their respective user make changes, they grow apart. Therefore, it’s possible for this "child" model to merge its changes to and from the parent model.
A user can see the relationships between models in Manage Models > Projects > Model.
In this example, the model Coffee is the parent of the model Coffee_in_Coffee_2. This results from the Coffee_live version of the Coffee model being loaded into a new project. When edits are made in either the parent or child model, the changes can be merged between them.

[[File:Phenom-manage-model branching.png|600px|border]]

Clicking on a live or published model will display its characteristics on the right panel. The user will be able to edit some of the model's characteristics and the permissions of the model, provided the user has Admin or Owner privileges for that model.

[[File:Phenom-manage-model details2.png|border|800x800px]]

== Copy Project (Create Branch) ==
Copying a project allows for easy cloning of project content with just a click of a button. The resulting project will contain a child of all the live models of the source project and the same published models.

To copy a project, the user just needs to select a project from their project tree and click the copy project icon on the top-right.
[[File:Manage - Copybtn.png|none|800px]]
The copy project screen closely resembles the project creation screen, requiring the user to input a new name and description for the new project. Additionally, the user must choose whether to copy the existing permissions from the source project to the copied project before saving.
[[File:Manage - CopyCreate.png|none|800px]]

== PHENOM-Managed SDMs ==
PHENOM comes loaded with official FACE Shared Data Models (SDMs) for FACE Technical Standard Editions 2.1, 3.0, 3.1, and 3.2.

=== Creating a Project with an SDM ===
The user can create a project by importing a model file and/or selecting existing model.

If the user choses to import a model file containing an SDM, PHENOM will try to replace it with its managed version. This will allow the user to benefit from the ability to update SDM version in the future.
During import, PHENOM will scan the model and if it detects a <dm/> node with the exact same name as one of the managed SDM model, it will try to replace it. However, if the imported SDM model contains more content than what is present in the "official" SDM, the swap will not occur (e.g. a custom measurement was added to package inside the SDM).

If for some reason, an expected SDM doesn't swap to a PHENOM-managed SDM, the user can proceed as follows to manually do it:
# Click on Create New Model and import the model file; this may lead to several models being created from the original file
# Click on Create New Project, and instead of uploading a file, select all the models that were created in step 1 except for the SDM one. Instead of selecting that SDM model, select one of the PHENOM-managed SDM models
# (Optional) Delete the SDM model that was created in step 1

Alternatively, the user can chose to create the project by using one of the SDMs in the list of existing models.

=== Update a Project's SDM model ===

If the project contains a PHENOM-managed SDM, the user has the ability to switch between versions of the SDM on the Project details page.

If the project contains a custom version of an SDM, it is possible to replace it with a PHENOM-managed. To do so, the user needs to follow these steps:
# Delete the original project containing the custom SDM. In the confirmation window, DO '''NOT''' select any constituent models for deletion
# Create a new project, and instead of uploading a file, select all the models that were included in the original deleted project except for the SDM one, and of the PHENOM-managed SDM models
# (Optional) Delete the custom SDM model

== Sample Workflow ==
This section goes over a sample workflow which employs the PHENOM project and model structure concepts described in the sections above.
In the scenario laid out below, a group of users, Chris, Dave, Nick, and Riley are working on different parts of completing a data model and documenting a set of interfaces against it. Each of them plays a slightly different role in the process, and they will use some of PHENOM's Model management features to keep their work organized.

=== Part 1 – Chris ===
Chris is working on updating the Shared Data Model (SDM) the group is using to conform to the latest changes released in an accepted standard. The user loads an SDM content file to create a model.
[[File:Workflow-newModel.png|border|800px]]

[[File:Worlflow - CreatedSubmodel.png|border|300px]]

The user loads the model into an SDM_Editor project and begins to make the changes.

[[File:Worlflow - CreatingProject.png|border|800px]]

[[File:Workflow - SwitchProject.png|border|300px]]

Once the user has made the changes necessary to match a decided-upon standard, the user publishes a version v1 of his SDM model.

[[File:Workflow - PublishProject.png|border|300px]] [[File:Worklow - PublishedModel.png|border|300px]]

Chris is going to make further changes in the SDM_Editor project, but that will be for the next standard update. In the meantime, the user wants to make the static version of the SDM they just published available to the rest of his team, so the user gives them Read permissions to it. However, making further changes to the SDM is his job and the user wants to stay in control of the process, so the user does not give any of his colleagues permissions to either the live version of the SDM model or the SDM_Editor project.

[[File:Phenom-manage-example-chris-7.png|border|800px]]

=== Part 2 – Dave ===
Dave is working on creating a Domain Specific Data Model (DSDM) for the team to use - he will be referencing the SDM Chris released in his efforts. He creates a new project into which he adds the SDM version he has access to and a blank model which will contain the DSDM content he creates.

[[File:Workflow - Davecreate project.png|border|800px]]

After Dave has added some content to his DSDM model which references nodes in the SDM, he will see that his DSDM model is now listed as dependent on the SDM model he has been using – which means, it can no longer be loaded without it.

[[File:Workflow - Dependencies.png|border|800px]]

Nick and Riley will be documenting some interfaces against the domain model that Dave is working on. However, Dave does not want them to have to wait for him to have finished with all of his work before they can start. Also, as they work on their interface documentation, they may come up with good changes to the DSDM and suggest that they be included in Dave's work. So, Dave decided to share his project with Nick and Riley, giving them Read/Write permissions, which automatically gives them permissions to the active DSDM model version he's working on.

[[File:Phenom-manage-example-dave-4.png|border|800px]]

=== Part 3 – Nick & Riley ===
Nick and Riley will be documenting interfaces using the DSDM that was shared with them, but they will be working with different sets of interfaces, each in his own project.
If they try to create a new project with just the DSDM, they will be rejected because they must also load in the SDM that was used to create it and on which it depends.

[[File:Workflow - DepFailure.png|border|800px]]

Once they have the appropriate permissions to all of the content, they can create their individual project with the models to house their documentation work separate from the contents of both the SDM and the DSDM.
In the example below, Riley creates a RILEY_s_INTFC_DOC project including the DSDM_live model and a new blank model for his changes. By doing so, a new model, DSDM_IN_RILEY_S_INTFC_DOC, was created, inheriting from Dave’s DSDM_live.

[[File:Manage workflow - Final2.png|border|800px]]

Dave and Riley will now be able to independently edit DSDM content and merge changes between their two models as they see appropriate.
Whenever Dave makes new updates to the DSDM, Nick and Riley have the opportunity to pull in those changes into their copies of the model. When either one of them makes a change to the DSDM portion of his project that he thinks should be included in the official version, they can make a push request to Dave's project that he can then either approve or ignore.

File:Phenom-manage-active project.png

2025-09-24T20:49:59Z

Chris: Chris uploaded a new version of File:Phenom-manage-active project.png

Active project display

File:Phenom-manage-projects models list.png

2025-09-24T20:45:24Z

Chris: Chris uploaded a new version of File:Phenom-manage-projects models list.png

Projects and Models lists

File:Phenom-manage-projects models list.png

2025-09-24T20:39:06Z

Chris: Chris uploaded a new version of File:Phenom-manage-projects models list.png

Projects and Models lists