Architecture
SysML Diagrams
Block definition, internal block, parametric, state machine, use case, requirement, package, class, activity and sequence diagrams, and how each maps to the LML model.
On this page
- Overview
- Concepts
- How to use it
- When and why
- Open a SysML diagram
- Build a block structure (BDD)
- Define interfaces (IBD)
- Analyze with constraints (Parametric)
- Model modes (State Machine)
- Capture use cases
- Trace a requirement (Requirement Diagram)
- Worked example: the CubeSat EO-1 power subsystem
- Tips and good practice
- Common mistakes
- How it connects to other features
- The SysML editor
- Block Definition Diagram
- Internal Block Diagram
- Parametric Diagram
- State Machine Diagram
- Use Case Diagram
- Requirement Diagram
- Package Diagram
- Class Diagram
- Activity Diagram
- Sequence Diagram
- Keyboard shortcuts
- Options and settings
- Messages
- Limits
- Related pages
Overview
Holarch draws the SysML diagram types as views of the same LML model that every other page uses. Nothing on a SysML diagram is stored only in the picture. Every box, port, compartment row and line is an entity or a relationship.
The main SysML elements map to LML like this:
- a block is an Asset;
- a part is a decomposed by child;
- a connector is a Conduit;
- a constraint block is an Equation;
- a state is a labelled Characteristic.
Because of this, the Database, the Interface Register, Budgets, the RVTM and the Simulator all see the same data as the diagram.
This page covers ten diagram types:
| Diagram | Root entity | Category | Shows |
|---|---|---|---|
| Block Definition Diagram | Asset | SysML | Blocks with values, constraints, operations and ports; composition, aggregation and associations |
| Internal Block Diagram | Asset | SysML | Nested parts and ports of a block, connectors (Conduits) and item flows |
| Parametric Diagram | Equation | SysML | Constraint blocks, parameters and bound block values, solved with units |
| State Machine Diagram | Asset or Characteristic | SysML | States, composite and parallel states, regions and transitions |
| Use Case Diagram | Action | SysML | Use cases, actors, include/extend and system boundaries |
| Requirement Diagram | Statement or Requirement | SysML | Requirements with containment and trace links |
| Package Diagram | Asset | SysML | Nested packages and their dependencies |
| Class Diagram | Asset | General | UML classes with attributes and operations; Java import |
| Activity Diagram | Action | SysML | The action flow in activity notation, with pins and swimlanes |
| Sequence Diagram | Action | SysML | Lifelines (Assets) and messages (Input/Outputs) of an action flow |
Diagrams covers what every diagram shares: the canvas, zoom, toolbar groups, export, annotations and thumbnails. The Action Diagram and the FFBD are covered in Action Diagrams and Functional Analysis.
Concepts
Diagrams are views, not drawings
Each SysML diagram has a root entity, and it draws what the model says about that root.
- Adding a block from the palette creates an Asset and the relationship that places it (for example decomposed by).
- Removing a shape (Delete) drops that relationship. The entity stays in the project.
- Deleting it (⇧Delete / Shift+Delete or Delete Item…) removes the entity everywhere.
Layout is saved per diagram and per root: positions, sizes and which compartments show. Every change, including a move, can be undone with a single Undo.
The same Asset can appear on a BDD, an IBD, an Asset Diagram and a Physical I/O Diagram at once. An edit in one view shows in all of them.
How SysML maps to LML
| SysML element | Holarch entity or relationship |
|---|---|
| Block | Asset (gets the Block label when a BDD opens on it) |
| Part property | Child Asset: parent decomposed by part |
| Part multiplicity | Multiplicity attribute of the decomposed by relationship |
| Port | Port entity, decomposed by its owning block (ports can own ports) |
| Port direction | Port Direction: None, In, Out, In and Out |
| Port type | Port instantiates an Asset (labelled Interface Block) or an Input/Output |
| Conjugated port | Port Conjugated attribute (shown as ~Type) |
| Value property | Characteristic, block specified by value (Value and Units attributes) |
| Constraint property | Equation, block equation of constraint |
| Operation | Action, block performs operation |
| Operation parameter / return | Input/Output: operation receives parameter, generates return type |
| Composition | decomposed by |
| Aggregation | related to |
| Generalization | extended by (Class Diagram) |
| Association | A Logical entity named "A connects to B"; both blocks connected by it, with a Multiplicity on each end |
| Connector (IBD) | Conduit; both ends connected by it |
| Connector direction | Origin attribute of each connected by relationship |
| Item flow | Conduit transfers Input/Output |
| Constraint block | Equation; its expression is the Value attribute |
| Constraint parameter | Characteristic, constraint has variable parameter |
| Binding connector | Parameter related to block value |
| State | Characteristic with the State label |
| Initial, final, history, parallel state, region | Additional labels Initial State, Final State, History State, Parallel State, Region State |
| Composite state | State decomposed by substates |
| Transition | Transition entity: source pushes transition, transition fetches target; Guard, Trigger Type and Probability attributes |
| Transition effect | Transition decomposed by an Action |
| Entry / do / exit behavior | Action labelled Entry Action, Do Action or Exit Action; state specifies action |
| Use case | Action with the Use Case label, decomposed by the diagram root |
| Actor | Asset that performs the use case |
| Include / extend | include / extend relationships between use cases |
| Package | Asset with the Package label; containment is decomposed by |
| Package dependency | related to, with the Context attribute (import, access, apply, conform, dependencyType, reference) |
| «satisfy», «verify», «deriveReqt», «refine», «copy», «trace» | satisfies, verifies, derives, refines, copies, traced to |
| Requirement containment | decomposed by |
| Activity action, fork/join, decision, loop | The action flow of the root Action (see Action Diagrams) |
| Swimlane | Asset that performs the actions inside it |
| Lifeline / message | Performing Asset / Input/Output generated by one action and received by another |
Diagram-managed relationships
The board-style diagrams are BDD, IBD, Class, Package, Parametric, State Machine, Use Case and Requirement. On these, the relationships the diagram draws are locked in the inspector's Trace section while the diagram is open.
Change those relationships on the canvas instead. That way the drawing and the model cannot disagree.
How to use it
When and why
Use SysML diagrams for architecture and design questions, once the requirements and functions exist. Pick the diagram by the question you need to answer:
- Use Case Diagram (concept definition): who uses the system, for what, and where the system boundary is. Use it with stakeholders before writing system requirements.
- Requirement Diagram (requirements analysis and reviews): how one requirement derives from others, and which blocks, functions, constraints and test cases satisfy or verify it.
- Block Definition Diagram (after functional analysis, when you allocate functions to a physical structure): the system breakdown, the value properties you will budget, and the operations each block performs.
- Internal Block Diagram (interface design): which parts connect, through which ports, carrying which items. It feeds the Interface Register and the ICD.
- Parametric Diagram (design analysis and trade studies): the equations that tie block values together, such as power, mass and link budgets, checked with units.
- State Machine Diagram: the operational modes and fault behavior of a block.
- Activity and Sequence Diagrams: behavior. They show the same action flow as the Action Diagram, in SysML notation, with swimlanes or lifelines.
- Package Diagram: organize a large model into packages and record import dependencies.
- Class Diagram: software structure, including import from Java source.
Open a SysML diagram
- Open Diagrams at the bottom of the rail and click + New Diagram. Or select an entity anywhere and use its Open in ▾ menu (New Diagram of This Item… starts a diagram on it).
- Choose the diagram type.
- Pick a root that fits the type:
- an Asset for BDD, IBD, Package, Class and State Machine;
- an Equation for Parametric;
- an Action for Use Case, Activity and Sequence;
- a Statement or Requirement for the Requirement Diagram.
The diagram opens fitted to the window. The Add panel is on the left. The inspector opens on the right when you select something.
To show the same root as another diagram type, use the type selector in the page header.
Build a block structure (BDD)
- Open a Block Definition Diagram on the system Asset.
Holarch adds the Block label to the root.
- Drag Block from the Add panel onto the root block.
You see a new Asset "New Block" below the root. A composition line joins them, with a filled diamond at the root end.
- Select the new block.
- Change its name and number in the inspector.
- Drag Value onto a block.
You see a Values compartment row "New Characteristic: —".
- Select the row.
- Set the Value (for example
2.1 kg) and Units in the inspector. - Drag Operation onto a block for each function the block performs.
- Drag Input Parameter or Return Type onto an operation row to add its parameters.
- Drag Port onto a block to add a port on its border.
- Set the port's Direction in the inspector.
To relate two blocks without composition:
- Select one block.
- Drag a green handle onto the other block.
- Release on it and choose Association in the connect chooser.
Use Depth + to show more decomposition levels, or All for every level. Use View ▾ to hide ports, values, constraints or operations.
Define interfaces (IBD)
- Open an Internal Block Diagram on a subsystem Asset.
You see its parts and ports nested inside the root frame.
- Drag Block onto the root (or into a part) to add a part.
- Drag Port onto a part's border to add a port.
- Select a part or port.
- Drag a green handle onto another part or port.
- Release on the target. The connector is made at once. When you drag from a port onto a block, choose Connect To Block or Add conjugated port in the connect chooser.
You see a Conduit "new connector" joining them.
- Select the connector.
- Set Item Flow in the inspector: Undirected, Directed, Reverse or Bidirectional.
- Add the Input/Outputs the connector carries, under Conveyed Items (Item Flows). Click a suggestion under Exchanged by the ends, or use + Add Item ▾.
- Set Interface Status, Owner and TBD/TBR.
- Click + Link Requirement… to link interface requirements.
- Read the Capacity Check. To enable it, set the Conduit's Capacity and Units in its attributes.
- Click Interface Register in the toolbar to list every connector on the diagram.
- Click Export CSV in the register to download the list.
Analyze with constraints (Parametric)
- Create an Equation for the analysis, for example "Power Budget".
- Open a Parametric Diagram on it.
- Drag Constraint (Equation) onto the canvas.
- Select the constraint and type its equation in the Value attribute, for example
P_gen = A*Eta*S*cos(Theta). - Drag Parameter (Characteristic) onto the constraint, once per variable.
- Name each parameter exactly as in the equation:
P_gen,A,Eta,S,Theta. Set Units on parameters where it helps. - Add the blocks that hold the values. Either drag Block (Asset) onto the canvas (or find one with Add or find…) and drag Value (Characteristic) onto it, or bring blocks in through their bound values.
- Select a parameter port.
- Drag its handle onto a block value row and release. Bind is the only choice, so it is made at once.
You see a binding line from the parameter to the value.
- Read the badge on each constraint: ✓ OK, ↻ Solve, ✓ Pass, ✕ Fail, … Needs input or ⚠ Error. Point at a badge for the details.
- Click Solve All.
The dialog lists every value that would change and the state of each constraint.
- Click Apply N Changes.
The values are written, and a single Undo takes it all back.
Model modes (State Machine)
- Open a State Machine Diagram on the Asset whose modes you model.
- Drag Initial State, State and Final State onto the canvas.
- To make a composite state, drag a State into another state.
- Select a state.
- Drag a handle onto the next state and release. The Transition is made at once.
You see a Transition "New Transition" with an open arrow.
- Select the transition.
- Set Trigger (name), Guard, Trigger Type, Probability and Effect in the inspector.
The label reads
name [guard] / effect. - Drag Entry Action, Do Action or Exit Action onto a state to add its behaviors.
For concurrent behavior:
- Drag Parallel State onto the canvas. It starts with two regions.
- Drag states into its regions.
Capture use cases
- Create an Action for the system's use, for example "Operate EO-1 System".
- Open a Use Case Diagram on it.
- Drag Subject onto the canvas.
- Double-click the boundary to set its title.
- Drag its blue corner to resize it.
- Drag Use Case into the boundary, once per use case.
- Drag Actor beside the boundary, once per user or external system.
- Connect an actor to a use case. Performs is made at once.
- Connect two use cases and choose «include» or «extend» in the connect chooser.
Trace a requirement (Requirement Diagram)
- Open a Requirement Diagram on a requirement or a section.
You see the root, its children to the chosen Depth, and everything linked to them by a trace relationship.
- Drag Asset, Action or Test Case onto a requirement.
The element appears with a «satisfy» arrow (Asset, Action) or a «verify» arrow (Test Case) to the requirement.
- To use an item that already exists, type its name in the Add search. Under In the project, the search lists the project's statements, requirements, assets and actions (✓ marks those on the diagram). Drag one:
- onto a requirement: a Test Case verifies it, an asset or action satisfies it, and a requirement without a parent goes inside it;
- onto an empty spot: the item is shown on this diagram, and the model does not change.
Each drop can be undone with a single Undo. A relationship that already exists is not added again, and a requirement that already has a parent stays where it is: draw a line to trace or derive it instead.
- Connect two requirements and choose Containment (decomposed by) or Trace (traced to).
- To change a trace to «deriveReqt», «refine» or «copy», select the line and use Relationship ▾.
- Use Attributes ▾ to choose which requirement attributes the boxes show.
Worked example: the CubeSat EO-1 power subsystem
The demo project contains a SysML diagram of every main type. Create it with Manage Projects → Project Files ▾ → New Demo Project.
1. BDD of EO-1 Spacecraft (1)
- Select EO-1 Spacecraft and choose Open in ▾ → Block Definition Diagram.
You see the six subsystems at Depth 1: Payload Camera, ADCS, EPS, C&DH, Communications, and Structure and Thermal. Their values show, for example Launch Mass: 10.4 kg, Battery Capacity: 77 Wh and Downlink Rate: 10 Mbps. Operations are hidden with View ▾ → All Operations.
- Click + in Depth to show level 2.
The EPS parts appear: Solar Arrays, Battery Pack and Power Distribution Unit. The Solar Arrays line shows multiplicity 2.
2. IBD of EPS (1.3)
- Open the Internal Block Diagram on EPS.
You see Solar Arrays, Power Distribution Unit and Battery Pack inside the EPS frame. The boundary port 12 V Bus (direction Out) is on the right edge. The connectors are Array Power (IF-20), Battery Power (IF-21, both ways) and Regulated Bus (IF-22).
- Select Battery Power.
Item Flow reads Bidirectional, because both ends are origins.
3. Parametric of EPS Power Budget (EQ-1)
- Open the Parametric Diagram on EPS Power Budget.
You see two constraints:
- Solar Power Generation holds
P_gen = A*Eta*S*cos(Theta). Its parameters bind to Cell Area (0.2 m^2), Cell Efficiency (0.295) and Peak Array Power on Solar Arrays. They also bind to Solar Flux (1361 W/m^2) and Sun Incidence Angle (0.35 rad) on Orbit Environment. - Battery Depth of Discharge holds
DoD = E_ecl/C_bat, bound to the Battery Pack values.
- Solar Power Generation holds
- Select Cell Area on Solar Arrays and change its Value to
0.22.The Solar Power Generation badge changes to ↻ Solve.
- Click Solve All.
The dialog shows Peak Array Power changing to about 83 W (0.22 × 0.295 × 1361 × cos 0.35), with How = Computed.
- Click Apply 1 Change.
To check requirement 3.1 (28 W orbit-average):
- Drag Constraint (Equation) onto the canvas.
- Set its Value to
P_gen >= 28[W]. - Drag Parameter (Characteristic) onto it and name it
P_gen. - Bind the parameter to Peak Array Power.
The badge reads ✓ Pass.
4. State machine of EO-1 Spacecraft
Open State Machine Diagram on EO-1 Spacecraft. You see:
- Initial → Launch → Detumble → Nominal Imaging ⇄ Downlink Contact;
- Undervoltage [bus < 6.4 V] (Change Event) into Safe Mode, and Recovery Command back out;
- End of Mission into Decommissioned.
Safe Mode shows do / Orient Arrays to Sun.
5. Use cases of Operate EO-1 System (UC)
The EO-1 Mission System boundary holds six use cases.
- Imagery Customer performs Request Imagery and Receive Image Products.
- Mission Operator performs the others.
- Collect Imagery «include» Plan Imaging Campaign.
- Recover from Safe Mode «extend» Monitor Spacecraft Health.
6. Requirement diagram of 3.1 Orbit Average Power
Requirement 3.1 shows «deriveReqt» to 1.5 Daily Collection Volume. «satisfy» arrows come from Solar Arrays, function F3 and the constraint EQ-1.1.
7. Sequence of Run Nominal Imaging Pass (OPS)
Open Sequence Diagram on Run Nominal Imaging Pass. You see:
- the lifelines Ground Station, UHF Transceiver, C&DH, ADCS, Payload Camera, S-band Transmitter, Power Distribution Unit and Mission Operations Center;
- Imaging Plan passing from Ground Station to UHF Transceiver;
- the loop Each target ×4 as a loop fragment, and the alternative Contact in view? as an alt fragment.
Tips and good practice
- Model first, then draw. If the Database already holds the structure (for example from an import), open a BDD or IBD and set the Depth. The diagram draws itself.
- Name parameters exactly as the equation does. A name in the equation that is not a parameter of that constraint is an error: "x" is not a parameter of this constraint.
- Put units on values, not only numbers:
12 kg,150 ft/min. The parametric solver converts units and reports dimension errors. - Use multiplicity on compositions. Budgets and roll-ups use the Multiplicity you set on a composition line as the count.
- Type ports with interface blocks. Set a port's Type. When you connect a port to a block, use Add conjugated port to get the conjugated counterpart automatically.
- Prefer Remove over Delete. Delete only drops the relationship that placed the element. Use ⇧Delete / Shift+Delete or Delete Item… only when the entity is wrong everywhere.
Common mistakes
- A new block disappears after you drop it on the empty canvas.
- On a BDD, a block dropped on empty canvas stays as a free block. You see Block added. Connect it to another block to relate it in the model.
- On other diagrams, an entity that no relationship places is not shown: Not shown: X is saved but not connected to this diagram.
- Fix: drop onto a parent, or connect it.
- The connect gesture is refused. A red frame on the target means no relationship fits, for example a transition into an initial state. Read the message and connect a valid pair.
- A constraint shows … Needs input. At least two of its variables have no value. Bind the parameters to values that hold numbers, or give the parameters values.
- A constraint shows ⚠ Error "The result is power, but P_gen is in kg". The bound value's Units do not match the equation's dimension. Fix the Units or the equation.
- The sequence diagram shows a "No performer" lifeline. Some actions have no performer. Click Assign performer… on that lifeline (or Assign Performer… in the toolbar) and choose the Asset, drag them into a swimlane on the Activity Diagram, or set performed by.
How it connects to other features
- Functional analysis → BDD and Activity. Functions from Functional Analysis are Actions. Allocate them to blocks with performs. They then appear as operations on the BDD and inside swimlanes on the Activity Diagram.
- IBD → Interfaces. IBD connectors are the Conduits listed in the Interface Register, the Interface Control Diagram and the ICD document export. See Other Diagrams and Interfaces.
- BDD values → Budgets. Value properties are Characteristics. Budgets & TPMs roll them up with the composition multiplicities (Budgets & TPMs).
- Parametric → Requirements. Constraint Equations can satisfy requirements (EQ-1.1 satisfies 3.1). The RVTM and the Requirement Diagram then show the analysis.
- Activity and Sequence → Simulator. Both edit the same flow as the Action Diagram, which the Simulator runs. ▶ Simulate ▾ on the Activity Diagram opens it.
- Every diagram → documents and presentations. Diagrams render into documents, review packages and slides. They export as PNG, SVG, HTML and DOCX (Diagrams).
The SysML editor
BDD, IBD, Class, Package, Parametric, State Machine, Use Case and Requirement Diagrams share one editor. The Layer, Physical I/O and Interface Control Diagrams use it too (other diagrams). The Activity and Sequence Diagrams have their own editors, described in their sections.
Toolbar
The type's own buttons come first. Then come these shared controls, shown only where the type uses them:
| Control | What it does |
|---|---|
| Depth − n + / All | How many decomposition levels to draw: − and + step one level, All draws every level. Without a saved depth the diagram opens at the deepest level that shows at most 60 shapes, and the number is in italics. The depth you choose is saved with the diagram. |
| View ▾ | Show or hide compartments and overlays. A ✓ marks what shows. |
| Frame | Checkbox: draws the diagram frame. Its colour is in Arrange ▾ → Diagram Settings → Frame: a colour picker that applies at once, and Automatic to return to the standard grey-blue. A colour chosen before stays. |
| Relationship ▾ | Change the relationship type of the selected line. Enabled only when a line with alternatives is selected. |
| Remove | Remove the selection from the diagram (same as Delete; Shift+click deletes the entities). Disabled for the diagram root. |
| Arrange ▾ | Tidy Layout (⇧⌘L / Ctrl+Shift+L) returns every shape to the automatic layout. Restore Defaults also returns to the automatic depth and the default view settings. |
The Diagram frame (SysML) is drawn around the content with the header kind [Class] Name. kind is bdd, ibd, par, stm, uc, req, pkg or act. For example: bdd [Asset] EO-1 Spacecraft. All frame-capable diagrams of the same root share the frame settings.
On the BDD and IBD, Arrange ▾ → Pictures shows or hides pictures. It draws each block's picture (the entity image) at the bottom of the box.
Palette
The Add panel (Palette):
- With the field empty: the type's items. Point at an item to see where it can go ("Drop onto a block", "Drop on the diagram").
- Type a name: Create "name" as <item>, then In the project: matching entities of the classes the diagram accepts (up to 60, by number), or No matching items in the project.
To insert an item, drag it onto the canvas or onto a target shape. The shape under the pointer highlights. With the keyboard, focus an item and press Enter or Space to insert it at the center of the view.
Canvas gestures
| Gesture | Result |
|---|---|
| Click a shape | Select it; the inspector shows the entity. |
| Click a compartment row | Select that member (value, constraint, operation, state behavior). |
| Click a line | Select the relationship; the inspector shows the relationship panel. |
| Drag a shape | Move it. Positions are saved per diagram. |
| Drag a shape into a container | Re-parent it (IBD, Package, State Machine, Layer; the target highlights green). Dropping on empty canvas makes it a child of the root. |
| Drag a port | Slide it along its block's border. On the IBD, drag it more than 30 px off the border onto another block to move it there. |
| Drag a green handle | Rubber-band connect. Four handles appear around a selected shape, one outside a selected port. |
| Release on a target | The relationship is made. When there are several (for example Part (composition) and Association), the connect chooser at the pointer asks which; 1–9 pick, Esc cancels. |
| Double-click a shape | Open its Item View (IBD part: its own IBD; Package: its package diagram; Use Case boundary: rename). |
Inspector
Shape selected: the entity panel with Remove and Delete Item…, and its Item, Attributes, Trace, Discussion and Details sections. On the IBD, a port also shows Type and Conjugated, and a connector shows the interface section.
Line selected: a Relationship panel. It shows:
- the two ends and the kind, for example Part (composition);
- Relationship;
- the line's own entity (a Conduit, Logical or Transition) with Inspect;
- the relationship attributes the type exposes, for example EPS's Multiplicity;
- the type's extra fields;
- Remove and Delete Item….
Delete and remove
- Delete, Backspace, Remove removes the element from this diagram at once and drops the relationship that placed it there. The entities stay in the project. The note Removed from diagram. offers Undo and Delete Item….
- ⇧Delete / Shift+Delete or Delete Item… asks first, then deletes the entities and all their relationships. On the BDD, deleting a block also deletes its ports, values, constraints, operations and their parameters.
See Remove and delete.
Both Remove and Delete can be undone with ⌘Z / Ctrl+Z.
Block Definition Diagram
A BDD shows blocks and their features. The root Asset gets the Block label when the diagram opens.
What it shows
- Blocks: the root and the blocks reachable within the Depth through decomposed by, related to and associations, plus free blocks you placed. Ports and states are not drawn as blocks.
- Compartments: each block is a «block» box with these compartments:
- Values:
name: units(or the value, or—) for each Characteristic the block is specified by. - Constraints:
name { equation }for each Equation the block is equation of. - Operations:
name(param: Units, …) : returnfor each Action the block performs. A parameter without Units showsAny.
- Values:
- Ports: small squares on the border with a direction glyph: In (arrow in), Out (arrow out), In and Out (both), or none.
- Lines:
- composition: filled diamond at the whole, open arrow at the part, part multiplicity at the part end;
- aggregation: open diamond;
- association: plain line labelled with the Logical's name and both multiplicities.
Toolbar and palette
- Toolbar: Depth, View ▾ (All Ports, All Values, All Constraints, All Operations), Frame, Relationship ▾, Remove, Arrange ▾.
- Add panel: Block, Port, Value, Constraint, Operation, Input Parameter, Return Type.
- In the project (type in Add or find…): Assets, Characteristics, Equations, Actions and Input/Outputs.
| Drop | Onto | Result |
|---|---|---|
| Block | a block | New part of that block (decomposed by) |
| Block | empty canvas | Free block on this diagram, with the hint to connect it |
| Port | a block | New Port decomposed by the block |
| Value | a block | New Characteristic, block specified by it |
| Constraint | a block | New Equation, block equation of it |
| Operation | a block | New Action, block performs it |
| Input Parameter | an operation row | New Input/Output the operation receives |
| Return Type | an operation row | New Input/Output the operation generates |
An existing entity dropped from the Add panel's In the project list goes to the slot that matches its class.
Connecting
From a block to another block, the connect chooser offers Part (composition) (decomposed by) and Association (connected by, through a Logical connection).
- Only the association is offered when the target is already a part, or when the composition would create a cycle.
- A simple association creates a Logical "A connects to B" with Multiplicity
1..1on both ends.
Relationship ▾ on a composition, aggregation or association line offers Composition, Aggregation and Association. The composition's inspector shows Part's Multiplicity. The association's inspector shows both ends' multiplicities.
Internal Block Diagram
An IBD shows the parts and ports inside a block, the connectors between them, and the items they carry.
What it shows
- Parts: the root is a large container with its parts nested inside, to the chosen Depth. Parts are child Assets (not ports, not states).
- Ports: on the borders of the root and of each part. They are labelled
name : Type,name : ~Typewhen conjugated, or the plain name. - Connectors: Conduits whose two ends are shown. The label is the Conduit name, plus
[Interface Status]when set.- An over-capacity connector turns red with ⚠ over capacity.
- A unit mismatch turns orange with ⚠ unit mismatch.
- Item flows: the Input/Outputs each connector transfers, in green italics, with a triangle for direction. A circle means the direction is not set. Point at an item flow for "Item flow (forward): …".
The item-flow direction comes from the first of these that applies:
- the performing actions (an action on one side generates the item, an action on the other receives it);
- the port directions;
- the connector's Item Flow setting.
Toolbar and palette
- Interface Register lists the diagram's connectors with Interface, Endpoints, Status, Owner, TBD/TBR, Items, Requirements and Capacity. It also shows status counts and All Conduits in the project. Export CSV downloads it.
- Toolbar: Depth, View ▾ (Item Flows), Frame, Remove, Arrange ▾.
- Add panel: Block (a new part, numbered under its parent) and Port (onto a block).
- In the project: Assets. Dropping an existing Asset into a part adds it there and keeps its other parents. If it is already a child, you see Already in that place on the diagram.
Connecting
- Connect (onto a port) and Connect To Block (onto a block) both create a Conduit "new connector". Both ends are connected by it.
- Add conjugated port is a second choice when you drag from a port to a block. It adds the counterpart port on the target block and connects the two. The new port has the same name and type, Conjugated flipped and Direction reversed.
- Duplicates are refused with An element cannot connect to itself. Drag to a different element. and These elements are already connected.
Connector inspector
| Field | Meaning |
|---|---|
| Item Flow | Undirected, Directed, Reverse, Bidirectional (sets the Origin of each end) |
| Name's Multiplicity | Multiplicity on each connected by end |
| Conveyed Items (Item Flows) | Items this connector carries, with their direction. Items of child conduits are marked (child conduit). × stops conveying an item. Empty: No items. Add the Input/Outputs this connector carries. |
| Exchanged by the ends: | Suggestions: Input/Outputs generated on one side and received on the other that the connector does not carry yet. Click + name to add one. |
| + Add Item ▾ | Existing Input/Output… or New Input/Output… |
| Interface Status | Not set, Draft, Proposed, Agreed, Baselined |
| Owner | Person or team |
| TBD/TBR | Not set, None, TBD, TBR |
| Interface Requirements | Linked requirements (traced from or satisfies); + Link Requirement…; × unlinks. New requirements created from the picker get the Interface Requirement label. |
| Capacity Check | Within capacity: 3.2 of 10 Mbps (32%)., Over capacity: …, No Capacity set; the load is not checked. or No conveyed items. Items whose units do not convert are listed as not counted. |
The capacity check adds up each conveyed item's Data Rate (in Data Rate Units), or its Size (in Units). It converts the total to the Conduit's Units and compares it with the Conduit's Capacity.
Port inspector
- Type: Set Type… picks an Asset (it gets the Interface Block label) or an Input/Output. Change… and Clear follow. Shows Untyped when none.
- Conjugated (reverse the type's flows; shown as ~Type).
- Direction in the attributes: None, In, Out, In and Out.
Parametric Diagram
A Parametric Diagram shows constraint blocks with parameters bound to block values, evaluated with units.
The root is an Equation, and its child Equations are the constraints. If the root's own Value is an equation (it contains =, < or >), the root is a constraint too.
What it shows
- Constraints: rounded «constraint» boxes with the name, the equation in braces, and a status badge. Parameters are small ports on the border, labelled
name: units. - Root parameters: Characteristics the root has variable, in a column on the left. Every constraint can use them by name.
- Blocks: «block» containers holding value boxes (name, value and units). A block appears automatically when one of its values is bound to a parameter. Add others with Block (Asset).
- Binding connectors: lines from a parameter to the value it is bound to.
Toolbar and palette
- Solve All evaluates every constraint, solves single unknowns and sets of constraints that share unknowns, checks inequalities, and previews the values to write.
- Solve does the same for the selected constraint only (and the constraints solved together with it). With no constraint selected, it acts like Solve All.
- Frame, Remove, Arrange ▾.
- Add panel:
- Constraint (Equation);
- Parameter (Characteristic): onto a constraint for a parameter, onto the canvas for a root parameter, onto a block to become a value;
- Block (Asset);
- Value (Characteristic) (onto a block).
- In the project: Equations, Characteristics and Assets.
- Connect: drag a parameter's handle onto a value. The only choice is Bind (related to), made at once. Released elsewhere, you see Parameters bind to block values. Drop it onto one.
How the network is solved
- Each constraint's equation is parsed. Every name in it must be a parameter of that constraint, a root parameter, or a constant (
PI,pi,E,g0= 9.80665). - A parameter's variable is its bound block value when it has one. Otherwise it is the parameter's own Value.
- Two constraints that bind to the same value share it. This links them into a network.
- An equation of the form
y = expressiondefinesy, whenyis a parameter that does not appear on the right. The first definition of a variable drives it. Later ones become checks. - Definitions are computed in dependency order. Loops are iterated until they settle (up to 200 passes).
- An equation with exactly one unknown input is solved numerically for it.
- The equations still waiting, with several unknowns in one equation or unknowns shared between equations, are solved together. They are split into the smallest sets that depend on each other, in the order they can be solved, and each set is solved at once. For example,
a + b = 10anda - b = 2givea = 6andb = 4, and a definitionc = a * bthat uses them is computed after them.- Units: each unknown takes the Units of its bound value. Without Units, it takes the dimension an equation gives it where it is the only unknown without one, else it is a plain number.
- Bounds: a check such as
x <= 0(one unknown alone on one side, a known value on the other) keeps the solution inside it. An absolute temperature (°C, °F) stays at or above 0 K. - Under-constrained: with fewer equations than unknowns, the constraints show … Needs input with Under-constrained: there are not enough equations to find "x", "y". Add an equation or give one of them a value.
- Over-constrained: with more equations than unknowns, the extra equations are checked with the solution. One that does not hold fails with Over-constrained: the other equations already fix these values….
- Not independent: when the equations do not fix one value of each unknown (for example
a + b = 10and2*a + 2*b = 20), the set shows ⚠ Error. - No solution found: when no value satisfies the set (for example
x^2 + y^2 = -1), the set shows ⚠ Error. - Limits: up to 1,000 unknowns in one diagram's network and 50 in one set, and a fixed amount of work per network. The work is counted, not timed, so the same diagram always gives the same values.
- Remaining equations and inequalities (
<=,>=,<,>,!=,==) are checks, with a relative tolerance of 10⁻⁶. - A new value is written as a number when the value has its own matching Units attribute. Otherwise it is written as text with a unit (
83.0 W).
Badges
| Badge | Meaning |
|---|---|
| ✓ OK | Computed or solved, and the stored value is up to date |
| ↻ Solve | Computed, but the stored value differs; Solve All would write it |
| ✓ Pass | Check satisfied |
| ✕ Fail | Check not satisfied |
| … Needs input | A variable has no value: Needs a value for x. |
| ⚠ Error | The equation or units are wrong (point at the badge for the message) |
Solve dialog
The dialog is titled Solve All Constraints (or Solve Constraint). It shows:
- "N values will change:", with the columns Value, Parameter, Current, New and How (Computed, Solved for input or Solved together (set N));
- when sets were solved together, a Solved Together table: Set, Constraints, Unknowns, Iterations, Residual (the largest remaining error relative to the size of the values) and Result (Solved, Not independent, No solution found, Stopped at the work limit, Not solved or Too many unknowns);
- a Constraints table with each constraint's state (Computed, Solved for input, Solved together, Pass, Fail, Under-constrained, Over-constrained, Needs input, Error) and message.
Apply N Changes writes the values as one undo step (Updated N values). With nothing to change, you see No values change. Every computed value is up to date. and Close.
Units and expressions
- Values with units:
12 kg,3.5 W,150 ft/min,$1.2M. - Units inside an equation: put the unit in brackets after a number:
9.81[m/s^2],28[W]. - Operators:
+ - * / ^and parentheses. - Functions: sqrt, abs, sin, cos, tan, asin, acos, atan, atan2, exp, log, ln, log10, pow, min, max, floor, ceil, round. Trigonometric functions need a plain number or an angle.
- Prefixes: SI prefixes from atto to yotta on the units that take them (kW, mA, GB, µs). Binary prefixes Ki, Mi, Gi, Ti and Pi on bit and byte. Unit names also work (meter, kilowatt, hours).
- Dimension checks: adding mass to power is an error. The result's dimension must match the bound value's Units.
Supported units:
- Length: m, in, ft, yd, mi, nmi, mil, au, ly.
- Mass: g, t, lb, oz, slug, ton.
- Time: s, min, h, d, wk, mo, yr.
- Speed and acceleration: mph, kph, kn, fps, gn.
- Force: N, lbf, kgf, dyn.
- Power and energy: W, hp, J, Wh, cal, BTU, eV.
- Pressure: Pa, bar, atm, psi, ksi, torr, mmHg, inHg.
- Electrical: A, V, Ω/ohm, Ah.
- Frequency: Hz, rpm.
- Data: bit/b, B, KB, bps, Bps, Kbps.
- Angle: rad, deg/°, arcmin, arcsec, rev.
- Temperature: K, °C, °F, °R, and the differences Δ°C, Δ°F.
- Area and volume: ha, acre, L, gal, qt, pt, floz, cc.
- Amount: mol.
- Ratios and counts: %, ppm, ppb, ea/each/pcs/count.
- Cost: $ or USD, $K, $M, $B.
State Machine Diagram
A State Machine Diagram shows the states and transitions of an Asset, or of a Characteristic used as a composite state.
What it shows
- Top states: Characteristics labelled State that the root Asset is specified by. For a Characteristic root, its decomposed by children.
- Initial state: filled circle. Final state: bullseye. History state: circle with H. Their names appear below.
- State: rounded «state» box. Behaviors show as rows
entry / name,do / name,exit / name. - Composite state: a state containing substates (decomposed by), drawn as a container, to the chosen Depth.
- Parallel state: «parallel state» container with stacked, dashed «region» compartments.
- Transitions: open arrows labelled
name [guard] / effect. States are ordered along the transitions: initial first, final last. - Legacy transitions: transitions stored as plain Actions (older models) are orange and labelled Older transition (an Action).
Palette
- Add panel: Initial State, Final State, History State, State, Parallel State (created with two regions), Region (onto a parallel state), and Entry Action, Do Action, Exit Action (onto a state).
- In the project: Characteristics and Actions. An existing entity gets the labels of the slot it fills.
Drop rules:
- States go onto the canvas (top level) or into a state (substate).
- States dropped on a parallel state must go into one of its regions.
- A region stays inside a parallel state.
- A state has at most one entry, one do and one exit behavior.
Connecting and the transition inspector
Drag from a state onto another and release over Transition. Holarch creates a Transition "New Transition": the source pushes it, and it fetches the target.
| Field | Meaning |
|---|---|
| Trigger (name) | The transition's name, shown first in the label |
| Guard | Condition text, shown in brackets |
| Trigger Type | Signal Event, Call Event, Change Event or Time Event |
| Probability | 0–100%: the chance the transition fires when its trigger occurs and the Guard cannot be evaluated; with no Guard, the chance the triggered transition fires. Empty: the Guard decides. |
| Effect | The Action run on the transition. Set… / Change… picks it, Clear removes it. None when empty. |
For a legacy transition, the panel says Stored as an Action. Convert it to a Transition. Click Change to Transition to convert it.
Use Case Diagram
A Use Case Diagram shows use cases, the actors that perform them, and system boundaries. The root is an Action, and the use cases are its child Actions.
What it shows
- Use cases: an ellipse for each child Action. New ones get the Use Case label.
- Actors: stick figures for every Asset that performs a use case on the diagram, plus actors you placed. Actors sit to the left or right of their use cases.
- System boundaries: grey titled rectangles. They are drawings on this diagram only, not entities.
- Lines: performs is a plain line from actor to use case. «include» and «extend» are dashed, with an open arrow.
Palette and editing
- Add panel: Use Case, Actor (a new Asset "New Actor"), and Subject (the UML subject: 200 × 400, titled with the root's name).
- In the project: Actions and Assets.
- Link by dropping: drop a use case onto an actor to make the actor perform it. Dropping an actor onto a use case creates the same link.
- Rename a subject: double-click it (Subject → Name).
- Resize a boundary: drag its blue bottom-right corner (at least 120 × 120).
- Open an entity: double-click a use case or actor to open its Item View.
- Remove an actor: it leaves the diagram and loses its performs links to the use cases shown.
- Remove a use case: it is no longer a child of the root.
Connecting
The connect chooser offers:
| From → To | Choices |
|---|---|
| Use case → use case | «include» (source includes target) and «extend» (source extends target) |
| Actor → use case | Performs |
| Use case → actor | Performed by |
Any other pair shows Connect a use case to a use case (include or extend), or an actor to a use case. Relationship ▾ switches a line between «include» and «extend».
Requirement Diagram
A Requirement Diagram shows requirements and the elements that satisfy, verify, derive, refine, copy or trace them. The root is a Statement or Requirement. A document section works well as the root.
What it shows
- Content: the root and its decomposed by children to the chosen Depth, every entity linked to them by a trace relationship, and elements you placed.
- Boxes: «Requirement», «Statement», «Asset», «Action», «Test Case» and so on. Requirement boxes show
Id = number,Text = description(up to three lines), then each requirement attribute that has a value. - Containment: a line with ⊕ at the parent.
- Trace lines: dashed, with an open arrow from client to supplier, labelled «copy», «deriveReqt», «refine», «satisfy», «verify» or «trace».
Toolbar and palette
- Attributes ▾ → Attributes to Show: Id, Text, each requirement attribute, and Attribute Names (show or hide the
Name =prefixes). - Depth, Frame, Relationship ▾, Remove, Arrange ▾.
- Add panel: Requirement, Statement, Asset, Action, Test Case, Other Class… (opens Choose Class).
- In the project: any entity.
Drop rules:
- A statement dropped onto a statement becomes its child, numbered next under it.
- Any other element dropped onto a requirement gets the default trace: Test Case → «verify»; Asset or Action → «satisfy»; others → «trace».
- A statement dropped on empty canvas becomes a child of the root.
- Any other element dropped on empty canvas is placed on this diagram only.
- Two non-requirements dropped on each other show Connect it to a requirement, or it leaves the diagram.
Connecting
- Between two statements or requirements: Containment (decomposed by) or Trace (traced to).
- Between a requirement and another element: the default trace for the element, plus «trace» (traced to).
- At least one end must be a statement. Otherwise: A requirement relationship needs a Statement or Requirement at one end.
Relationship ▾ offers:
- containment (two statements);
- copy, deriveReqt and refine (two requirements);
- satisfy (not between two statements);
- verify and trace.
Package Diagram
A Package Diagram shows packages nested by containment, with their dependencies. The root is an Asset, and the packages are its child Assets.
- Shapes: folder-tab packages. A package with children is drawn as a container with its name in the tab, to the chosen Depth.
- Dependencies: dashed lines with an open arrow, labelled
«import»or the dependency's Context. - Add panel: Package (an Asset with the Package label). In the project: Assets.
- Nesting: drag a package into another to move it (decomposed by). Drag it onto the canvas to make it a child of the root.
- Connecting: Containment (decomposed by) or «import» (related to, context import).
- Relationship ▾: access, apply, conform, dependencyType, import, reference (sets Context), or containment. The inspector shows Context.
- Double-click a package to open its own Package Diagram.
Class Diagram
A Class Diagram shows UML classes with attributes and operations. It is listed in the General category. The root is an Asset, and the classes are its child Assets.
- Shapes: class boxes with Attributes (
name: type) and Operations (name (param types) : return) compartments. - Lines: composition, aggregation, generalization (open triangle at the parent) and associations. An association whose ends have Origin set shows ▶, ◀ or ◀▶.
- View ▾: All Attributes, All Operations, Relationship Attributes: the association end multiplicities, and under each association's name its attributes, as in an LML entity-relationship-attribute (ERAA) diagram: each line of the Logical connection's Relationship Attributes text, then each Characteristic that specifies the Logical as
name: value units(up to six lines, then "+n more"). An association with none shows only its name. - Palette: Class, Attribute, Operation, Input Parameter, Return Type. Members go onto a class (Drop onto a class). Parameters go onto an operation row.
- Connecting: Part (composition) or Association.
- Relationship ▾: Aggregation, Composition, Generalization (extend), Association. An association's inspector shows each end's Multiplicity and Origin.
Import Java
- Click Import Java….
The dialog Import Java Source opens.
- Click Choose .java File…, or paste the source. Reset clears it.
- Click Apply.
You see Imported N classes. A single Undo takes back the whole import.
The import maps Java to the model like this:
- Each class, interface or enum becomes a child Asset. Its description is the modifiers and kind.
- Fields become Characteristics (Units = type, Value = initializer).
- Enum constants become Characteristics with Units
enum. - Methods and constructors become performed Actions. Each parameter becomes a received Input/Output. The return becomes a generated "method() result" Input/Output (Units = type).
extendsbecomes extended by.
Activity Diagram
An Activity Diagram shows the root Action's flow in SysML activity notation. It edits the same flow as the Action Diagram. A change in either shows in both, and the Simulator runs it.
What it shows
- Start and end: an initial node (filled circle) and an activity final node (bullseye).
- Actions: rounded boxes with number and name. A rake symbol marks a decomposed action. Click it to open the child's activity diagram.
- Fork/Join: black bars around parallel branches. A branch with a Branch Performer is labelled «actor».
- Decision/Merge: diamonds around alternative branches, with guards and probabilities.
- Loop: a merge and a decision diamond, labelled
[continue ×N] name. - Flow final (⊗): an EXIT.
- Pins and object flows: each Input/Output an action generates is an output pin on its right edge. Each one it receives is an input pin on its left edge. A green line, labelled with the item name, joins them.
- Swimlanes: horizontal or vertical bands named after an Asset.
- Guards: yellow note shapes with free text.
Toolbar
| Control | What it does |
|---|---|
| ▶ Simulate ▾ | Discrete Event or Monte Carlo: opens the Simulator on this root |
| + Branch | Add a branch to the selected Fork/Join or Decision (Select a Fork/Join or Decision first otherwise) |
| Decompose | Open the selected Action's child activity diagram |
| Flatten | Put the child flow of the selected Action in its place |
| Remove | Remove the selection from the diagram (⇧Delete / Shift+Delete deletes the entities) |
| Swimlane ▾ | Horizontal Swimlane…, Vertical Swimlane… (pick the Asset), Auto Lanes by Performer (one band per performing Asset), Remove All Swimlanes |
| I/O | Show or hide pins and object flows |
| Frame | Diagram frame (SysML) (act); its colour is in Diagram Settings |
| Generate Asset Diagram | Create "Root performers": an Asset that performs the root, decomposed by every performer, with Conduits carrying the I/O exchanged between them. Then opens its Asset Diagram. |
Palette
- Add panel:
- Action, Fork/Join, Decision (Or) and Decision (Loop), all onto a control-flow edge;
- Branch Performer, onto a Fork/Join branch edge;
- Guard, a free note;
- Swimlane, dropped where the lane goes.
- In the project:
- Actions, onto an edge;
- Assets: onto an action, the Asset performs it; onto a branch edge, it becomes the Branch Performer; elsewhere, it becomes a swimlane;
- Input/Outputs, onto an action: the action generates it.
- Arrange ▾ → Tidy Layout (⇧⌘L / Ctrl+Shift+L) places every element again.
Gestures
- Drag an action onto another action: creates a new Input/Output "I/O" that the first generates and the second receives (as a trigger).
- Drag an element onto a control-flow edge: moves it there.
- Drag a swimlane by its header: moves it. Drag its corner to resize it (at least 80 × 60).
- Swimlane membership: actions whose centre lies inside a manual lane are performed by its Asset. Actions moved out lose that link.
- Double-click a guard: edit its text.
Inspector
- Action or I/O: the entity panel with Open Activity, Flatten (when decomposed), Remove and Delete Item….
- Decision / Merge: Decision (the question), then Guards and probabilities: a guard and a % per branch. × removes a branch. Also + Branch, Remove and Delete Item….
- Fork / Join: one row per branch, Branch n — «actor» Name, with Clear Performer. × removes a branch. Also + Branch.
- Loop: Iterations (sets the loop to count mode).
- Swimlane or Guard: Remove.
The activity editor sets decisions by probability and loops by count only. Use the Action Diagram for resource, script and prompt decisions.
Sequence Diagram
A Sequence Diagram shows the root Action's flow as lifelines and messages.
- A lifeline is an Asset that performs actions in the flow.
- A message is an Input/Output generated by an action on one lifeline and received by an action on another.
What it shows
- Lifelines: a header per performing Asset, with a dashed line. Actions no asset performs go on the No performer lifeline, shown last in the warning colours with Assign performer…: click it (or the toolbar's Assign Performer…) and choose an Asset; it then performs every Action on that lifeline (a single Undo takes it all back; <Asset> now performs N Actions).
- Actions: activation bars on their performer's lifeline, in flow order.
- Messages: green arrows labelled with the Input/Output name.
- Fragments: par (parallel), alt (decision, with
[guard p%]per branch) and loop (label ×N) frames. ⊗ EXIT marks an exit.
Toolbar and palette
- + Lifeline ▾: New Asset Lifeline… or Existing Asset Lifeline….
- Add Existing Action…: pick an action, then click the lifeline that sends it and the lifeline that receives it. A bar at the bottom of the diagram says which click is next and also offers both lifelines as lists with Add (the keyboard way); after the first click, Without a Message (or Esc) adds the action to the sender only, and Cancel stops. Holarch adds the action to the flow, makes the sender perform it, and adds a message to the receiver. Error: Add a lifeline first.
- Assign Performer… (while a No performer lifeline exists): see above.
- Remove.
- Warnings appear when an action has several performers (X has multiple performers), or when an action waits for a trigger that is never generated in this flow (Infinite loop: …).
- Palette: Lifeline (Asset), the Asset classes and Action. Dropping an Asset places its lifeline at that position (Only an Asset can be a lifeline. Drop an Asset.). Dropping an Action (new, or found in the project) on a lifeline makes that Asset perform it; dropping it in the gap between two lifelines makes the left one send it to the right one as a message. The action goes into the flow at the drop height, and a single Undo takes it all back.
- Arrange ▾ → Reset Lifeline Order puts the lifelines back in their automatic order.
Gestures
Add a message:
- Drag from one lifeline to another.
Holarch creates the following, and a single Undo takes it all back:
- a sending action "New Action N" on the source lifeline;
- the Input/Output "New Input/Output", generated by the sending action;
- the receiving link, with Trigger on, to the target lifeline's next action after the drop point. When that lifeline has no later action, Holarch creates a new "New Action N" there.
- The message is selected and its name is selected in the inspector: type the Input/Output's name and press Enter. Rename the new actions the same way.
Other gestures:
- Drag a lifeline header sideways to reorder lifelines.
- Drag an action up or down to reorder it within its sequence.
- Double-click a header, action or message to open its Item View.
- Delete removes a message from the diagram (drops the generated-by and received-by links); ⇧Delete / Shift+Delete deletes the Input/Output after a confirmation.
- Select a lifeline header and press Delete (or Remove) to take it off the diagram. Its actions in this flow lose performed by: Removed from diagram. N Action(s) lost their "performed by" relationship.
Keyboard shortcuts
| Key | Action |
|---|---|
| Delete or Backspace | Remove the selection from the diagram (the entities stay) |
| ⇧Delete / Shift+Delete | Delete the selected entities from the project, after a confirmation |
| Esc | Clear the selection |
| Enter or Space on a palette item | Insert it at the center of the view |
| ⌘Z / Ctrl+Z / ⇧⌘Z / Ctrl+Shift+Z | Undo / redo (every edit, move and layout change) |
Canvas keys (zoom, pan, search) are the same as in every diagram: see Diagrams.
Options and settings
| Setting | Where | Saved |
|---|---|---|
| Depth | Toolbar | Per diagram (automatic until you choose one) |
| Compartments and overlays | View ▾ | Per diagram |
| Diagram frame (SysML) and colour | Frame (toolbar) and Arrange ▾ → Diagram Settings → Frame | Per root, shared by its frame-capable diagrams |
| Pictures | Arrange ▾ → Pictures (BDD, IBD) | Per diagram |
| Requirement box attributes | Attributes ▾ | Per diagram |
| Shape positions, port sides, boundaries, free blocks | Canvas | Per diagram; reset with Arrange ▾ |
| Swimlanes, guard notes, I/O toggle | Activity toolbar | Per diagram |
| Lifeline order | Sequence canvas | Per diagram |
Messages
| Message | Meaning and fix |
|---|---|
| Those entities cannot be connected here. | No relationship fits the pair. Connect a valid pair. |
| Not shown: X is saved but not connected to this diagram. | The new entity exists but nothing places it here. Connect it or drop it onto a parent. |
| This depth has more than 2,000 shapes, so only the first 2,000 are shown. Lower the depth to see all of them. | The diagram is capped at 2,000 shapes. Lower the Depth. |
| An entity cannot go inside one of its own children. Drop it elsewhere. | The drop would create a decomposition cycle. |
| The diagram root cannot be removed. | Remove or delete other elements; the root defines the diagram. |
| This composition would make a block part of itself. / This containment would put an element inside itself. | The target already contains the source. |
| Block added. Connect it to another block to relate it in the model. | A free block on the BDD; connect it to give it a place in the structure. |
| Drop onto a block / Drop onto a class / Drop it onto an operation row / Drop onto a state / Regions go in a parallel state. Drop it onto one. / States go in one of the regions. Drop it into a region. | The palette item needs that target. |
| This diagram cannot show that entity. | The class does not fit any slot here. |
| This state already has a Entry Action. (Do Action, Exit Action) | One of each behavior per state. |
| A region belongs in a parallel state. Drop it onto one. / A state cannot go inside itself. Drop it outside. | Invalid state nesting. |
| An initial state has no incoming transitions. Connect to another state. | Connect into another state. |
| Connect a use case to a use case (include or extend), or an actor to a use case. | Invalid use case connection. |
| A requirement relationship needs a Statement or Requirement at one end. | Connect at least one requirement. |
| Connect it to a requirement, or it leaves the diagram. | Two non-requirements were dropped together. |
| Parameters bind to block values. Drop it onto one. | Bindings go from a parameter to a value. |
| An element cannot connect to itself. Drag to a different element. / These elements are already connected. | IBD duplicate or self connection. |
| Already in that place on the diagram. | The Asset is already a child of that part. |
| Unit support is not loaded. Reload the page. | Reload, then solve again. |
| "x" is not a parameter of this constraint. Add it as a parameter or fix the equation. | Add the parameter or fix the name. |
| Needs a value for x. | Give the variable (or its bound value) a value. |
| Unknown unit "u". Use a unit such as kg, W, m/s or %. | Fix the unit text. |
| Unknown function "f". Use sqrt, abs, … | Use a supported function. |
| Cannot add dimension and dimension: the dimensions differ (…). | The equation mixes incompatible units. |
| The result is dimension, but x is in unit. Fix the units of the bound value or the equation. | The computed result does not match the target's Units. |
| "…" is not an equation. Write it as "y = expression", or use <=, >=, < or >. | The Value has no comparison. |
| "…" has more than one comparison. Use one = or inequality per constraint. | Split it into two constraints. |
| No value of x satisfies … | The solver found no solution for the single unknown. |
| Under-constrained: there are not enough equations to find "x", "y". Add an equation or give one of them a value. | Fewer equations than unknowns in a set. |
| Over-constrained: the other equations already fix these values, and this equation does not hold for them. Remove an equation or a value. | An extra equation contradicts the solution. |
| The equations do not fix one value for each of "a", "b": … | The equations depend on each other (not independent). |
| No solution found for "x", "y". Check the equations and their units. | No values satisfy the set. |
| Stopped at the work limit before "x", "y" could be found. … | The set needs more work than one solve allows. Give some values. |
| Too many unknowns to solve together (n; the limit is 50). Give some of them values. | A set is larger than 50 unknowns (or the network larger than 1,000). |
| Not solved: it needs "x", which the solver did not find. | An earlier set failed. Fix that set first. |
| … Give "V", "I" a unit (the Units of the bound value). | Unknowns without Units made the dimensions differ. |
| The constraint loop did not settle after 200 passes. Check the equations and the start values. | A circular set of definitions diverges. |
| No Java package declaration found ("package …;"). / No Java class found. Paste or upload code that declares a class. / The file is not a Java file. Upload a .java file. | Java import problems. |
| Select an Action to decompose / Select an Action with a child diagram to flatten / The child diagram is empty. Add Actions to it before flattening. | Activity Decompose and Flatten need a suitable action. |
| A Fork or Decision must keep at least two branches. | Keep two branches or delete the construct. |
| That Action is already on this diagram or is its parent. Choose another Action. | An Action appears once per flow. |
| An element cannot go inside itself. Drop it outside. | Moving a construct into its own branch. |
| Drop onto a control-flow edge / Drop a Branch Performer onto a Fork/Join branch edge / Drop the Input/Output onto an Action | Activity palette targets. |
| No Action here has a performing Asset. Add swimlanes or relate Actions to Assets first. | Generate Asset Diagram needs performers. |
| Created "name" with N Asset(s) and N Conduit(s). | Generate Asset Diagram finished. |
Limits
- Board diagrams draw at most 2,000 shapes. The automatic depth looks up to level 10; + and All go deeper.
- View ▾, Depth and layout are per diagram. The entities are shared by every view.
- The Activity editor sets decisions by probability and loops by count only. Edit other decision and loop modes in the Action Diagram.
- The Parametric solver solves at most 50 unknowns together in one set and 1,000 in one diagram. It finds one solution of each set; when a set has several (for example
x^2 = 4), add a check such asx >= 0to choose one. - Java import reads class structure with a pattern parser. It ignores method bodies, generics detail and annotations, and it needs a
packagedeclaration. - System boundaries, guard notes, swimlanes and frames are diagram drawings, not entities. Reports and exports include them; the Database does not.
Related pages
- Diagrams: the shared canvas, toolbar, export and annotations
- Action Diagrams: the flow that Activity and Sequence Diagrams edit
- Functional Analysis: functions to allocate to blocks
- Simulation: run the activity flow
- Other Diagrams: Asset, Physical I/O, Interface Control, Layer, IDEF0, N2 and more
- Help: Block Definition Diagram, Internal Block Diagram, Parametric Diagram, Interfaces, Conduits and ICDs, Budgets & TPMs