Reference › Language reference › Functional analysis, operations & the app

Reference › Language reference

Functional analysis, operations & the app

Use cases, system functions, operating modes, and what the Arche app shows.

On this page: use-case · system-function · function-flow · function-chain · step · edge · operating-mode · story · step · benchmark · run · panel · widget · app · page · tab · visual · animation · rule · table · column · unit · property · tag-group · plugin · menu · entry

Use cases, system functions with their flows and chains, operating modes, and what the Arche app shows: stories, benchmarks, panels and apps, visuals, rules, data tables, units, property definitions, tag groups, plugins and its menu. Each is one entry of an Arche list file; what it holds beyond its properties is written with attr.

use-case#

A use case (a Capella capability): what an actor does with the system, and the actors, components, functions, chains and scenarios it involves. Written to usecases.yaml (use_cases).

  • Keywords: use-case (old spelling: usecase)
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: use-case id "Label" { involves; extends; includes }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
involves list of element names Actors, components, functions, chains and scenarios it involves, by name (or as Arche addresses).
extends refs Use cases it extends.
includes refs Use cases it includes.
generalizes refs Use cases it generalizes.
file string The file it is written to.
use-case UC-POINT "Pointer le faisceau" en "Point the beam" {
  involves operator, kria, SF-POINT
  includes UC-STATUS
}

system-function#

A system function (functional analysis), allocated to the components that perform it. A function written inside another is one of its parts; its ports are in and out ports, with what they carry: out order "Order" sends command. Written to functional.yaml (systemFunctions).

  • Keywords: system-function
  • Set: functional analysis & scenarios
  • Where: top level, inside system-function
  • Syntax: system-function id "Label" { allocated; kind; states }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
allocated list of element names Components it is allocated to, by path (or as Arche addresses).
kind ident What kind of function it is, when not a plain one: duplicate, gather, route, select, split.
states refs The states and modes it is active in (Arche addresses).
file string The file it is written to.
system-function SF-POINT "Point the beam" {
  allocated kria.ps.app
  system-function SF-STEER "Steer the beam" {
    allocated kria.ps.app.tracking
    in target "Target" receives POINTING
  }
}

function-flow#

What flows from one system function to another (a Capella functional exchange): function-flow SF-A -> SF-B "attitude", its id in Arche after as: function-flow SF-A -> SF-B "attitude" as fl-att { name "attitude feed" }. An end may name the function's port: SF-A.out1 -> SF-B.in1; carries lists what it carries, when more than one thing. Written to functional.yaml (flows).

  • Keywords: function-flow
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: function-flow A -> B "item"
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
name string Its name, when it is not what flows (Arche shows it on the arrow).
carries refs What it carries (messages, exchange items).
file string The file it is written to.
function-flow SF-SENSE -> SF-POINT "attitude" as fl-attitude

function-chain#

A functional chain: system functions in order, with a budget. Written to functional.yaml (chains).

  • Keywords: function-chain
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: function-chain id "Label" { functions; budget }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
functions refs The functions, in order.
budget string Its time (or other) budget.
file string The file it is written to.
function-chain FC-TRACK "Tracking loop" {
  functions SF-SENSE, SF-ESTIMATE, SF-POINT
  budget "10 ms"
}

step#

A step of the chain: one system function (a function may take several steps), or a control node (kind and, kind or, kind iterate). Written to the steps of its funcchain.

  • Keywords: step
  • Set: functional analysis & scenarios
  • Where: inside function-chain
  • Syntax: step id { function; kind }
Property Value Meaning
function ident The system function.
kind ident A control node instead of a function: and, or, iterate.
step s1 { function SF-SENSE }

edge#

An edge between two steps of the chain, and the function flow it carries: edge s1 -> s2 : fl-1; when is the condition it is taken on. Written to the edges of its funcchain.

  • Keywords: edge
  • Set: functional analysis & scenarios
  • Where: inside function-chain
  • Syntax: edge A -> B : x
Property Value Meaning
when string The condition it is taken on (after a control node).
edge s1 -> s2 : fl-attitude

operating-mode#

An operating mode of the system (BOOT, STANDBY, TRACKING…): the components active in it (none named: all of them), the requirements that apply in it, and the modes it goes to — to STANDBY on PBIT_RESULT_OK when "every PBIT passed". Components and requirements are named as in the model (kria.ps, REQ-ANT-010) and written to Arche as its addresses. budget power 60W in a mode adds up the power of the components active in it, and the linter says when they draw more (checked by archec; Arche has no budget per mode). Written to modes.yaml (modes).

  • Keywords: operating-mode
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: operating-mode id "Label" { initial; components; requirements }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
initial bool The mode it starts in.
components list of element names Components active in it (none: all).
requirements list of element names Requirements that apply in it.
to any A mode it goes to: to MODE on TRIGGER when "guard" (repeatable).
budget any What the components active in it may draw at most: budget power 60W (sum), budget temperature max 85°C.
operating-mode STANDBY "Standby" {
  initial
  components kria, terminal
  requirements REQ-ANT-001
  to TRACKING on TRACK [a service is offered]
  budget power 60W
}

story#

A story: a guided presentation of the model, step by step (Présentation › Récits). Written to stories.yaml (stories).

  • Keywords: story
  • Set: the arche app
  • Where: top level
  • Syntax: story id "Label" { summary; group }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
summary text What it tells.
group string Where it is listed.
story antenna-stack "La pile logicielle" en "The software stack" { summary "…"; group "Architecture" }

step#

A step of the story: its title and text, and what it shows (a view, a file, visuals, a diagram…). Written to the steps of its story.

  • Keywords: step
  • Set: the arche app
  • Where: inside story
  • Syntax: step id "Label" { text; note; view }
Property Value Meaning
text text What the step says.
note text A note beside it.
view ident The view it opens.
file string The file the view shows.
image string An image.
visuals any Visuals it shows.
hardware any Hardware it shows.
scope any What the view is narrowed to.
layout any How the page is laid out.
diagram any A diagram it shows.
diagram-notes any Notes on the diagram.
code any Code it shows.
benchmarks any Benchmarks it shows.
deliverables any Deliverables it shows.
component any The component it is about.
scenario any The scenario it plays.
nominal any The nominal case.
trace any A trace it follows.
animate refs The animations (or visuals) it plays, by id: animate v-handover — the same list as visuals, checked against the project's.
dwell duration How long it stays before the next step when the story plays by itself (archec story export, a screen in a lab): dwell 8s.
step s1 "Le PS démarre" en "The PS starts" { text "…"; view canvas; file "KRIA260.yaml" }

benchmark#

A benchmark: a measured quantity, its target, and its runs. Written to benchmarks.yaml (benchmarks).

  • Keywords: benchmark
  • Set: the arche app
  • Where: top level
  • Syntax: benchmark id "Label" { subject; unit; compare }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
subject string What is measured.
unit string Its unit.
compare string How a run compares with the target (<=, >=…).
target any The target value.
requirements list of element names Requirements it measures, named as in the model (REQ-SW-034) or by their Arche address.
method text How it is measured.
benchmark BM-LOOP "Tracking loop period" { subject "cff"; unit us; compare "<="; target 1000; method "…" }

run#

A run of the benchmark: when, on which version, the value measured and the verdict. Written to the runs of its benchmark.

  • Keywords: run
  • Set: the arche app
  • Where: inside benchmark
  • Syntax: run id { at; version; value }
Property Value Meaning
at any When it ran.
version any The version measured.
value any The value measured.
result any Its verdict.
note text A note.
excluded any Left out of the trend.
subject any What was measured, when not the benchmark's subject.
run r1 { at "2026-09-12"; version "0.4.0"; value 820; result pass }

panel#

An operator panel (Simulation): a grid of widgets bound to the model. Written to panels.yaml (panels).

  • Keywords: panel
  • Set: the arche app
  • Where: top level
  • Syntax: panel id "Label" { columns; row-height; satisfies }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
columns number Columns of its grid.
row-height number Height of a grid row, in pixels.
satisfies refs Requirements it satisfies.
script text Python run with the panel.
panel operator "Opérateur" {
  columns 12
  row-height 40
  widget title "Pointage" { type text; at [0, 0, 12, 1] }
}

widget#

A widget of the panel: its type, its place on the grid (at col, row, width, height), and what it shows or does. Written to the widgets of its panel.

  • Keywords: widget
  • Set: the arche app
  • Where: inside panel
  • Syntax: widget id "Label" { type; at; bind }
Property Value Meaning
type ident text, slider, button, value, terminal, visual, chip, banner, section, segmented, dial, input, select, toggle, props, grid, led, table, log.
at any Its cell and span on the grid: [col, row, width, height].
bind string The model value it shows (app.state, cof.POINTING.azimuth).
action string What it does when used: Python run in the simulation.
min any Lowest value.
max any Highest value.
step any Step between values.
value any Its starting value.
unit string The unit shown.
port string The port it reads or writes.
message string The message it sends or shows.
visual string The visual it shows.
data any Its data.
states any The states it shows, and how.
http any The HTTP method it calls.
path string The path it calls.
api string The API it calls.
severity any Its severity (banners).
satisfies any Requirements it satisfies.
options any The choices offered.
rows any Rows (grids, tables).
cols any Columns (grids, tables).
show-values any Show the values (grids).
labels any Labels.
color any Its colour.
block any The block it shows, or its span.
widget az "Azimut" { type slider; at [0, 1, 4, 1]; min -60; max 60; step 0.5; unit °; value 20 }

app#

An application made of pages of panels. Written to panels.yaml (apps).

  • Keywords: app
  • Set: the arche app
  • Where: top level
  • Syntax: app id "Label" { nav; header; banners }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
nav string Navigation style.
header string Header text.
banners string Banners.
base-url string Base URL.
satisfies refs Requirements it satisfies.
app hmi "IHM" { nav "top"; header "Antenna"; base-url "/hmi" }

page#

A page of the app: the panel it shows, or tabs of pages. Written to the pages of its app.

  • Keywords: page
  • Set: the arche app
  • Where: inside app
  • Syntax: page id "Label" { panel; reference; icon }
Property Value Meaning
panel ident The panel it shows.
reference string A picture of what it should look like.
icon any Its icon.
page main "Pointage" { panel hmi-pointing }

tab#

A tab of the page: a page of its own. Written to the tabs of its page.

  • Keywords: tab
  • Set: the arche app
  • Where: inside page
  • Syntax: tab id "Label" { panel; reference; icon }
Property Value Meaning
panel ident The panel it shows.
reference string A picture of what it should look like.
icon any Its icon.
tab registers "Registres" { panel hmi-registers }

visual#

An image or drawing of the project, shown in its gallery. Written to visuals.yaml (visuals).

  • Keywords: visual
  • Set: the arche app
  • Where: top level
  • Syntax: visual id "Label" { file; group; height }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
file string The image file.
group string Its group in the gallery.
height number Height on the page.
comment text What it shows, under it.
data-file string The data it is drawn from.
visual stack "Software stack" { file "visuals/stack.svg"; group "Architecture"; height 400 }

animation#

An animation for the slides of a story: one of Arche's animation templates (archec animation list), and the content it draws, written as properties — stops, states, scenes… whatever the template reads. A value may name the model: a component is written as its name, a constant or parameter as ${NAME} (the app works it out on the slide, so the picture follows the design), machine draws a state machine and scenario plays a scenario. A list of names where the template wants records (stops [kria.ps, kria.pl]) gets the rest of each record from the template's sample. Written to visuals.yaml (visuals), with the drawing in visuals/.html and its content in visuals/.yaml — what Arche's animation editor writes.

  • Keywords: animation
  • Set: the arche app
  • Where: top level
  • Syntax: animation id "Label" from template { data…; height; group; duration }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
template ident The drawing it starts from, one of Arche's animation templates (archec animation list). Usually written in the header: animation v-x "…" from flow.
code string A drawing of its own: an HTML file (relative to this file), run in the same sandboxed frame. With a template too, the template says what data the code reads.
machine ref A state machine to draw: the component that has it (or its states). Fills the template's states, edges and walk — the states in the order they are reached.
scenario ref A scenario to play: its participants become the lifelines (actors), its steps the arrows (messages). scenario boot.nominal picks one of its sequences.
data-file string Where its content is written in the project (visuals/<id>.yaml by default) — to keep the name an Arche project already had.
height number Height on the page, in pixels.
group string Its group in the gallery.
comment text What it shows, under it.
duration duration How long one cycle lasts — what an export (GIF, .pptx) records.
fps number Frames a second an export records (10 by default).
params refs Parameters (or metrics) whose values the drawing is sent as arche.params: a parameter changed in a story moves the picture.
tags refs Tags.
variants refs The variants it belongs to.
animation v-handover "From the PS to the PL" from flow {
  stops [terminal, kria.ps, kria.pl]
  speed 220
  height 160
  group "Stories"
}

rule#

A project rule, checked by Arche's Problems view and by the linter, with the same verdicts: applies says which elements (component, port, link, requirement), when narrows them, check must hold for each, and message is what a breach says ({name}, {parent.name}… read the element). when and check are written as they read — check parentKind in ["processor", "software"] — in the expression language of parameters and budgets; what each kind of element offers (kind, parentKind, ports, tracesTo.verifies, fromPort.type…) is listed in Arche's rules.md. Written to rules.yaml (rules).

  • Keywords: rule
  • Set: safety, security & design space
  • Where: top level
  • Syntax: rule id "Label" { applies; when; check }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
applies ident The elements it applies to: component, port, link or requirement.
when string Which of them it is about: a condition, written as is.
check string What must hold for each: a condition, written as is.
severity ident error, warning (the default) or info.
message string What it says when it fails; {field} reads the element.
disabled bool Kept, but not run.
rule sw-on-cpu "Software runs on a processor" {
  applies component
  when kind == "software"
  check parentKind in ["processor", "software"]
  severity error
  message "{name} is software but does not run on a processor"
}

table#

A data table (a CSV the model reads), with its key and columns. Written to tables.yaml (tables).

  • Keywords: table
  • Set: the arche app
  • Where: top level
  • Syntax: table id "Label" { data; key; complete }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
data string The data file.
key refs The columns that identify a row.
complete bool Every key combination has a row.
unique refs Columns whose values together are unique to a row (repeatable).
file string The file it is written to.
table rfic-map "RFIC mapping" { file "rfic-mapping.yaml"; data "rfic-map.csv"; key elem_row, elem_col; complete }

column#

A column of the table, and the values it may hold: a range, or a list of values. Written to the columns of its table.

  • Keywords: column
  • Set: the arche app
  • Where: inside table
  • Syntax: column id { min; max; values }
Property Value Meaning
min any Lowest value.
max any Highest value.
values any The values it may hold.
type ident Its type.
unit string Its unit.
column pol { values "H", "V" }

unit#

A unit: its quantity, and how it converts to its base unit. Written to units.yaml (units).

  • Keywords: unit
  • Set: project tooling
  • Where: top level
  • Syntax: unit id "Label" { quantity; base; factor }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
quantity any The quantity it measures: time, length, or a quoted one ("angular rate").
base ident The base unit.
factor any Value of one of it in the base unit.
offset any Offset to the base unit.
alias refs Other spellings (repeatable).
symbol string How it is shown (µs, °/s).
logarithmic bool A logarithmic unit (dB): it does not convert by a factor.
unit ms "millisecond" { quantity time; base s; factor 0.001; alias msec }

property#

A property components carry (prop x = …, mass, power, cost): its type, unit and allowed values, the kinds of component it applies to, the group it is filed under (props.group.x). Capella's property values (PVMT) as Arche checks them. Written to properties.yaml (properties).

  • Keywords: property
  • Set: project tooling
  • Where: top level
  • Syntax: property id "Label" { type; unit; values }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
type ident string, int, float, bool or enum.
unit string Its unit.
values any The values an enum may take.
kinds refs The kinds of component it applies to (none: all).
group ident The group it is filed under.
default any Its value when a component has none.
property mass "Mass" { type float; unit kg; kinds system }

tag-group#

A tag group (Arche tag type), with its color. When declared, the groups are these and only these. Written to tag-types.yaml (tagTypes).

  • Keywords: tag-group
  • Set: project tooling
  • Where: top level
  • Syntax: tag-group id "Label" { color }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
color any Its color.
tag-group status "Statut" { color "#c62828" }

plugin#

A plugin of the Arche app. Written to plugins.yaml (plugins).

  • Keywords: plugin
  • Set: the arche app
  • Where: top level
  • Syntax: plugin id "Label" { kind; script }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
kind ident Its kind.
script string Its script.
plugin bench "Bench" { kind script; script "plugins/bench.js" }

The Arche app's left menu (menu.yaml): entry items, nested for groups. Without it, archec writes one entry per page the project has.

  • Keywords: menu
  • Set: the arche app
  • Where: top level
  • Syntax: menu { entry id "Label" { icon i; view v; file "f.yaml"; entry … } }
menu {
  entry models "Models" {
    icon folder
    entry model-car "Car" { icon layers; view canvas; file "car.yaml" }
  }
}

entry#

A menu entry: a page (view, file) or a group of entries.

  • Keywords: entry
  • Set: the arche app
  • Where: inside menu, inside entry
  • Syntax: entry id "Label" { icon i; view v; file "f.yaml" }
Property Value Meaning
icon ident Its icon.
view ident The page it opens.
file string The file the page shows.
section string The section of the page it opens at (a deliverable, a chapter).
entry requirements "Exigences" en "Requirements" { icon list; view requirements; file "requirements.yaml" }