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/
- 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" }
menu#
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, insideentry - 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" }