ArchiMate 3.x Semantic Projection

EdgeNode compiles digital twin structural ontologies into standardized ArchiMate 3.x enterprise architecture diagrams. By evaluating contours, we map definitions to architectural layers, resolving structural relationship verbs into connections.

Architectural Mapping Overview

A Digital Twin in EdgeNode reconciles multi-contour definitions into a single structural snapshot. The semantic views resolve each node's dominant Definition type and each edge's dominant Relation type, along with aggregated financial, temporal, and communication metrics.

Domain Concept	ArchiMate 3.x Construct	Visual Representation
Node Definition	Architectural Element in Layer	Layer-colored rectangle with `«kind»` stereotype
Accountable Role	RACI Governance Property	`Resp: <role>` label in element body
Edge Relation	Typed Relationship	Styled connector (line style + standard arrowhead)
Cumulative Latency	Relationship Metric Suffix	`<verb> (<latency>s)` text label
Labor Cost & Time	Element Quantitative Metrics	`Cost: $X` and `Time: Y` text annotations

Design Principles Behind the Mapping

Projection Isolation: The renderer consumes exclusively the semantic semantic graph, isolated from the execution plan.
Conformity with ArchiMate Standards: Structural symbols (layer palettes, shape geometry, relation arrowheads) strictly adhere to The Open Group's ArchiMate specification. Quantities (labor cost, cycle time) are rendered as clean textual annotations rather than non-standard symbols.
Semantic Verb Folding: Where EdgeNode provides richer relational verbs than the standard syntax, related domain verbs fold cleanly into standard ArchiMate relationship types while preserving the exact verb in the connector label.
Extensible Reserved Vocabulary: The compiler declares the complete ArchiMate element (23 kinds) and relation vocabulary; unmapped kinds serve as pre-allocated slots for future ontology extensions.

1. Architectural Layers (Horizontal Swimlanes)

In ArchiMate projections, horizontal swimlanes represent architectural strata, not organizational roles. The node's resolved definition type classifies it into an architectural layer and assigns its standardized color palette:

Definition Type	ArchiMate Layer	Element Kind	Shape Styling
`process`	Business	Business Process	Rounded Rectangle
`structural_unit`	Application	Application Component	Rounded Rectangle
`artifact`	Application	Data Object	Square Rectangle
`location`	Technology	Node	Square Rectangle
`concept`	Motivation	Principle	Rounded Rectangle

💡 Reserved Layer Allocations

The renderer pre-allocates Strategy and Implementation & Migration layers as reserved target strata for upcoming domain types.

2. Element Anatomy and Metrics

Every semantic node is rendered as an ArchiMate element block containing 4 distinct informational lines:

Line 1 — Name: The primary display name of the node in bold title text.
Line 2 — Stereotype & Governance: Displays «Element Kind» • Resp: <accountable role>. Sourced from definitions.accountable_id (RACI Accountable). Omitted if no accountable role is assigned.
Line 3 — Operational Labor Cost: Displays Cost: $<labor_cost>, representing the normalized wage expenditure across all assigned operational cycles.
Line 4 — Total Processing Duration: Displays Time: <total_processing_time>, representing the cumulative duration of cycles executed within this node.

Hidden Metric Annotations

The backend also calculates asset cost, volume and throughput entropy:

\text{Throughput Entropy} = \frac{1}{|A|} \sum_{a \in A} \text{entropy}(a) \quad \text{where } \text{entropy}(a) \in [0.0000, 1.0000]

These fields are retained within the element's metadata payload but remain visually hidden until an official Open Group visual placement standard is designated.

3. Relationship Folding and Connectors

EdgeNode folds its nine domain relationship verbs onto six standardized ArchiMate relationships. The specific database verb and cumulative latency are preserved in the text label: verb (cumulative_latency).

Domain Verb	ArchiMate Relationship	Line Style	Arrowhead Notation	Rendered Label
`composes`	Composition	Solid Line	Solid Diamond (◆) at source	`composes (Xs)`
`extends`	Specialization	Solid Line	Hollow Triangle (△) at target	`extends (Xs)`
`couples`, `requires`	Serving	Solid Line	Standard Arrow (→) at target	`couples (Xs)` / `requires (Xs)`
`constraints`, `influences`	Influence	Dashed Line	Standard Arrow (→) at target	`constraints (Xs)` / `influences (Xs)`
`aligns`	Realization	Dashed Line	Hollow Triangle (△) at target	`aligns (Xs)`
`alternates`, `characterizes`	Association	Solid Line	None (Plain Line)	`alternates (Xs)` / `characterizes (Xs)`

4. Layered Layout Algorithm

The ArchiMate rendering canvas applies a specialized topological rank layout:

Longest-Path Column Layering: Elements are arranged in stage columns based on dependency depth across all relationships except composes. Because composition represents structural containment rather than sequence or influence, it does not push elements horizontally.
Cell Stacking: When multiple elements occupy the same column and layer cell, they stack vertically in discrete tracks.
Horizontal Strata: Each active architectural layer spans the full canvas width as a continuous horizontal band.

5. Quantitative Cost Calculations

Labor costs shown on ArchiMate elements are derived by normalizing hourly, daily, weekly, and monthly wage rates against cycle durations:

\text{Labor Cost} = \sum_{c \in \text{Cycles}} \left( \frac{\text{epoch}(c.\text{duration})}{3600.0} \times \text{HourlyWage}(c.\text{responsible\_id}) \right)

Where the wage rate normalization is defined as:

\text{HourlyWage}(r) = \begin{cases} r.\text{wage\_rate} & \text{if } r.\text{rate\_unit} = \text{'hour'} \\ r.\text{wage\_rate} / 8.0 & \text{if } r.\text{rate\_unit} = \text{'day'} \\ r.\text{wage\_rate} / 40.0 & \text{if } r.\text{rate\_unit} = \text{'week'} \\ r.\text{wage\_rate} / 160.0 & \text{if } r.\text{rate\_unit} = \text{'month'} \end{cases}

Worked Example: Order Management Architecture

The following example demonstrates an enterprise digital twin projected into an ArchiMate 3.x layered view:

ArchiMate diagram showing cross-layer relationships between Business, Application, and Technology entities — Figure 3.0: Generated ArchiMate 3.x diagram illustrating layered enterprise dependencies.

Node Definitions

Node Name	Definition Type	Resolved Layer	Accountable Role
Order Process	`process`	Business	Ops Lead
Order Service	`structural_unit`	Application	Platform Team
Order Record	`artifact`	Application	—
EU Data Center	`location`	Technology	—
Data Sovereignty	`concept`	Motivation	—

Relationship Topology

Order Process $\xrightarrow{\text{requires}}$ Order Service: Business process serviced by an application component (Solid arrow).
Order Service $\xrightarrow{\text{composes}}$ Order Record: Application component composing a data object (Solid diamond ◆).
EU Data Center $\xrightarrow{\text{constraints}}$ Order Record: Technology node constraining data placement (Dashed arrow).
Data Sovereignty: Motivation principle governing cross-layer compliance.

Comparison: BPMN 2.0 vs. ArchiMate 3.x

Dimension	BPMN 2.0 Projection	ArchiMate 3.x Projection
Primary Scope	Plan (Execution & State Choreography)	Twin (Structural & Ontological Baseline)
Core Question	What does the system do?	What the system is?
Horizontal Lanes	Operational Roles (RACI Responsible)	Architectural Layers (Business, App, Tech)
Shape Palette	Events (Circles), Gateways (Diamonds), Tasks (Rectangles)	Rectangles with stereotype badges and corner variants
Role Display	Horizontal Swimlane container	Text badge inside element (`Resp: <role>`)
Edge Semantics	Artifact transitions, priorities, triggers	Architectural verbs (composes, requires, extends)