Auriga 1.0.0

Introduction

Auriga is a suite of dotnet libraries and tools that are used to deserialize (read), manipulate, and serialize (write) Eclipse Capella™ models. Capella is an open-source Model-Based Systems Engineering (MBSE) tool implementing the Arcadia method; its models are stored as Ecore-based XMI. Auriga makes the Capella semantic model (the five Arcadia architecture layers and the common packages) available as an in-memory .NET object graph, typically to support opinionated template-based code-generation and model transformation, and is a part of modeltopia.

Auriga builds on ECoreNetto for reading the Capella Ecore metamodel, and is a sibling of uml4net and SysML2.NET. Auriga provides a number of libraries that are described in the following sections.

Auriga

The core library that contains the Capella object model: the C# implementation of the Capella metamodel (the Arcadia layers — Operational Analysis, System Analysis, Logical Architecture, Physical Architecture, EPBS — and the common packages), generated from the Capella Ecore metamodel. Together with Auriga.Xmi it provides the capability to read and write Capella models and make them available as an in-memory object graph.

Auriga.Xmi

The Auriga.Xmi library provides an XMI reader implementation to read Capella semantic model files (.capella / .melodymodeller) and an XMI writer implementation to write them back. It resolves intra-file (xmi:id) and cross-file (href) references, including references that cross .capellafragment boundaries, into a fully resolved object graph. The writer serializes the graph back to Capella-faithful XMI, preserving the fragment layout — see XMI Writer.

Auriga.Extensions

The Auriga.Extensions library provides LINQ-style query extension methods over the Auriga object graph, following the uml4net.Extensions pattern: containment navigation (QueryAncestors, QueryRoot, QueryAllFunctions, QueryAllComponents), component-functional allocation (QueryAllocatedFunctions, IsAllocatedTo, QueryAllocatingBlocks), function/component ports and functional exchanges, and cross-layer realization (QueryRealizedFunctions/QueryRealizingFunctions and the component equivalents). See Query Extension Methods.

Auriga.Reporting

The Auriga.Reporting tool renders a browsable HTML report of the Capella metamodel from the vendored .ecore files, using the ECoreNetto HtmlReportGenerator — the same report generator used by the sibling projects (uml4net, SysML2.NET). The docker-build-docs-local.sh and docker-build-docs-attested.sh scripts render the report and serve it from an nginx image (HtmlDocs/Dockerfile). See Capella Metamodel HTML Report for build and run instructions. It is a development-time tool and is not published as a package.

Getting Started

Install the packages from NuGet (once published):

dotnet add package Auriga
dotnet add package Auriga.Xmi
dotnet add package Auriga.Extensions

Load a Capella project, navigate the Arcadia layers, query it, and write it back:

using Auriga.Xmi;
using Auriga.Extensions;

// 1) Load a project — pass the .capella / .melodymodeller file or the project directory.
//    Referenced .capellafragment files are discovered and resolved into one object graph.
var project = CapellaProject.Load("In-Flight Entertainment System/In-Flight Entertainment System.capella");

// 2) Navigate the Arcadia layers as first-class properties (null when a layer is absent).
var logical = project.LogicalArchitecture;
var physical = project.PhysicalArchitecture;

// 3) Query with LINQ and the Auriga.Extensions methods.
foreach (var component in logical!.QueryAllComponents())
{
    foreach (var function in component.QueryAllocatedFunctions())
    {
        // function.IsAllocatedTo(component) == true
    }
}

// Any element can walk its own subtree; combine with LINQ for ad-hoc queries.
var exchanges = project.Project!
    .QueryAllContainedElements()
    .OfType<Auriga.Fa.IFunctionalExchange>();

// 4) Write the (possibly modified) model back to disk — the fragment layout is preserved.
var writer = XmiWriterBuilder.Create().Build();
writer.Write(project.Project!, "out/In-Flight Entertainment System.capella");

See ContainerList Design, Query Extension Methods and XMI Writer for the containment, query and write-back APIs in depth.

Code Quality

Installation

Auriga is in early development and has not yet had its first release. Once published, the packages will be available on NuGet:

• Auriga — the Capella object model
• Auriga.Xmi — the .capella / .melodymodeller reader and writer
• Auriga.Extensions — query extension methods

Build Status

GitHub Actions are used to build and test the Auriga libraries.

Branch	Build Status
Master
Development

Documentation

Background and design documentation lives in the docs folder:

• Capella Metamodel Inventory — the .ecore files, the inter-package dependency graph, and the v1 code-generation scope
• Arcadia Semantics Not Visible in Raw Ecore — the layer, allocation, realization, and containment conventions the public API must respect
• ECoreNetto Validation Against the Capella Metamodel — proof that ECoreNetto loads the full Capella metamodel with fully resolved references
• Capella Metamodel HTML Report — building and hosting the browsable metamodel report (Auriga.Reporting, with Docker build scripts)
• Query Extension Methods — the Auriga.Extensions LINQ query set for functions, components, ports, exchanges, and cross-layer allocation/realization
• ContainerList Design — the non-bypassable Collection<T>-based containment collection and its exclusive-ownership (reject-not-steal) semantics
• XMI Writer — serializing the object graph back to Capella-faithful XMI (Auriga.Xmi), fragment layout, and the fidelity model
• Validation Against Real Capella Models — the round-trip validation harness, per-model results, and exactly how out-of-scope content (other versions, add-on viewpoints, diagrams) is handled

Capella and Arcadia Documentation

Eclipse Capella™ is an open-source MBSE tool hosted by the Eclipse Foundation. It implements the Arcadia method, a structured engineering method for the definition and validation of complex systems architecture. Learn more at https://mbse-capella.org and https://eclipse.dev/capella/.

Software Bill of Materials (SBOM)

As part of our commitment to security and transparency, this project includes a Software Bill of Materials (SBOM) in the associated NuGet packages. The SBOM provides a detailed inventory of the components and dependencies included in the package, allowing you to track and verify the software components, their licenses, and versions.

Why SBOM?

• Improved Transparency: Gain insight into the open-source and third-party components included in this package.
• Security Assurance: By providing an SBOM, we enable users to more easily track vulnerabilities associated with the included components.
• Compliance: SBOMs help ensure compliance with licensing requirements and make it easier to audit the project's dependencies.

You can find the SBOM in the NuGet package itself, which is automatically generated and embedded during the build process.

License

The Auriga libraries are provided to the community under the Apache License 2.0.

Eclipse Capella™ is a trademark of the Eclipse Foundation. Auriga is an independent project and is not affiliated with or endorsed by the Eclipse Foundation.

Contributions

Contributions to the code-base are welcome. However, before we can accept your contributions we ask any contributor to sign the Contributor License Agreement (CLA) and send this digitally signed to s.gerene@stariongroup.eu. You can find the CLA's in the CLA folder.

Contribution guidelines for this project