@memoarchitect/ontology 0.20.1 → 0.21.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (115) hide show
  1. package/README.md +1 -1
  2. package/examples/functional-logical-physical/model/catalog/functional_logical_physical.sysml +2 -3
  3. package/examples/gpca-pump/memo.identity.yaml +14 -13
  4. package/examples/gpca-pump/model/catalog/gpca_behavior_actions.sysml +44 -63
  5. package/examples/gpca-pump/model/catalog/gpca_context.sysml +4 -0
  6. package/examples/gpca-pump/model/catalog/gpca_operational.sysml +8 -0
  7. package/examples/gpca-pump/model/catalog/gpca_system.sysml +2 -0
  8. package/examples/gpca-pump/model/catalog/gpca_verification.sysml +2 -2
  9. package/examples/gpca-pump/model/catalog/viewpoints/logical/views/behavior_action_flow_view.sysml +1 -1
  10. package/examples/reusable-instrument/model/catalog/reusable_instrument.sysml +6 -0
  11. package/examples/surgical-closure-workflow/model/catalog/surgical_closure_workflow.sysml +8 -0
  12. package/examples/temperature-alarm/model/catalog/temperature_alarm.sysml +2 -0
  13. package/extensions/aadl/memo.package.yaml +1 -1
  14. package/extensions/aadl/src/runtime/memo_aadl_runtime.sysml +4 -0
  15. package/extensions/anatomy/memo.package.yaml +1 -1
  16. package/extensions/anatomy/src/selector/memo_extension_anatomy_selector.sysml +1 -0
  17. package/extensions/anatomy/src/vocabulary/memo_extension_anatomy_vocabulary.sysml +1 -0
  18. package/extensions/clinical/memo.package.yaml +1 -1
  19. package/extensions/clinical/src/procedures/memo_clinical_procedures.sysml +1 -0
  20. package/extensions/cloud/memo.package.yaml +1 -1
  21. package/extensions/cloud/src/cloud_extension.sysml +3 -0
  22. package/extensions/container/memo.package.yaml +1 -1
  23. package/extensions/container/src/container_extension.sysml +3 -0
  24. package/extensions/messaging/memo.package.yaml +1 -1
  25. package/extensions/messaging/src/messaging_extension.sysml +5 -0
  26. package/extensions/ros/memo.package.yaml +1 -1
  27. package/extensions/ros/src/ros_extension.sysml +58 -15
  28. package/methodologies/default/memo.package.yaml +1 -1
  29. package/methodologies/gpca/memo.package.yaml +1 -1
  30. package/ontology/memo.package.yaml +1 -1
  31. package/package.json +1 -1
  32. package/profile/memo.package.yaml +1 -1
  33. package/src/architecture/decisions/memo_decisions.sysml +9 -2
  34. package/src/architecture/functional/behavior/memo_behavior.sysml +21 -26
  35. package/src/architecture/functional/functions/memo_functions.sysml +10 -2
  36. package/src/architecture/implementation/hardware/common/memo_hardware_common.sysml +15 -4
  37. package/src/architecture/implementation/hardware/electrical/memo_hardware_electrical.sysml +8 -0
  38. package/src/architecture/implementation/hardware/fluidic/memo_hardware_fluidic.sysml +3 -0
  39. package/src/architecture/implementation/hardware/mechanical/memo_hardware_mechanical.sysml +3 -0
  40. package/src/architecture/implementation/hardware/optical/memo_hardware_optical.sysml +2 -0
  41. package/src/architecture/implementation/hardware/sensing/memo_hardware_sensing.sysml +3 -0
  42. package/src/architecture/implementation/software/runtime/memo_software_runtime.sysml +2 -0
  43. package/src/architecture/implementation/software/structure/memo_software_structure.sysml +12 -0
  44. package/src/architecture/implementation/ui/memo_ui.sysml +14 -0
  45. package/src/architecture/logical/interfaces/memo_interfaces.sysml +11 -2
  46. package/src/architecture/logical/structure/memo_logical_structure.sysml +16 -1
  47. package/src/architecture/operational/activities/memo_activities.sysml +3 -0
  48. package/src/architecture/operational/context/actors/memo_actors.sysml +5 -1
  49. package/src/architecture/operational/context/stakeholders/memo_stakeholders.sysml +4 -0
  50. package/src/architecture/operational/context/use_context/memo_use_context.sysml +5 -0
  51. package/src/architecture/operational/scenarios/memo_scenarios.sysml +1 -0
  52. package/src/architecture/operational/structure/memo_operational.sysml +5 -0
  53. package/src/architecture/operational/use_cases/memo_use_cases.sysml +4 -0
  54. package/src/architecture/operational/workflows/memo_workflows.sysml +5 -0
  55. package/src/architecture/realization/deployment/memo_deployment.sysml +12 -0
  56. package/src/architecture/realization/physical/memo_physical_architecture.sysml +6 -0
  57. package/src/architecture/variability/memo_variability.sysml +6 -0
  58. package/src/artifacts/configuration_management/memo_configuration_management.sysml +16 -0
  59. package/src/artifacts/core/memo_controlled_artifacts.sysml +16 -6
  60. package/src/artifacts/definitions/memo_artifact_definitions.sysml +1 -0
  61. package/src/artifacts/documents/risk_management/memo_risk_management.sysml +2 -0
  62. package/src/artifacts/standards/memo_artifacts_standards_traceability.sysml +4 -0
  63. package/src/assurance/cybersecurity/memo_cybersecurity.sysml +36 -0
  64. package/src/assurance/human_factors/memo_human_factors.sysml +4 -0
  65. package/src/assurance/requirements/memo_requirements.sysml +5 -1
  66. package/src/assurance/requirements/needs/memo_needs.sysml +2 -0
  67. package/src/assurance/safety_risk/analysis/memo_fmea.sysml +19 -0
  68. package/src/assurance/safety_risk/memo_risk.sysml +25 -1
  69. package/src/assurance/safety_risk/postmarket_surveillance/memo_postmarket_surveillance.sysml +2 -0
  70. package/src/assurance/verification_validation/clinical_evaluation/memo_clinical_evaluation.sysml +1 -0
  71. package/src/assurance/verification_validation/memo_assurance.sysml +5 -0
  72. package/src/core/annotations/memo_annotations.sysml +7 -0
  73. package/src/core/common/memo_common.sysml +28 -4
  74. package/src/core/consistency_rules/consistency_rules.sysml +5 -0
  75. package/src/core/enumerations/memo_enumerations.sysml +0 -5
  76. package/src/core/methodology_scope/methodology_scope.sysml +1 -0
  77. package/src/core/relationships/memo_relationships.sysml +9 -0
  78. package/src/core/relationships/memo_workspace_membership.sysml +1 -0
  79. package/src/methodology/core/memo_core.sysml +9 -0
  80. package/src/methodology/gates/memo_gates.sysml +1 -0
  81. package/src/methodology/patterns/memo_patterns.sysml +1 -0
  82. package/src/methodology/profiles/memo_profiles.sysml +2 -2
  83. package/src/methodology/rules/memo_rules.sysml +2 -0
  84. package/src/methodology/workflow/memo_workflow.sysml +3 -0
  85. package/src/rules/ontology/ontology_invariants.sysml +14 -0
  86. package/src/viewpoints/catalog/memo_viewpoint_catalog.sysml +1 -0
  87. package/src/viewpoints/clinical/clinical_viewpoint.sysml +1 -1
  88. package/src/viewpoints/clinical/views/clinical_evidence_view/clinical_evidence_view.sysml +2 -0
  89. package/src/viewpoints/clinical_workflow/clinical_workflow_viewpoint.sysml +1 -1
  90. package/src/viewpoints/context/context_viewpoint.sysml +1 -1
  91. package/src/viewpoints/cybersecurity/cybersecurity_viewpoint.sysml +1 -1
  92. package/src/viewpoints/cybersecurity/views/cybersecurity_assessment_view/cybersecurity_assessment_view.sysml +2 -0
  93. package/src/viewpoints/cybersecurity/views/threat_model_view/threat_model_view.sysml +2 -0
  94. package/src/viewpoints/definitions/memo_viewpoint_definitions.sysml +10 -0
  95. package/src/viewpoints/functional/functional_viewpoint.sysml +1 -1
  96. package/src/viewpoints/logical/logical_viewpoint.sysml +1 -1
  97. package/src/viewpoints/matrix/memo_matrix_views.sysml +4 -2
  98. package/src/viewpoints/operational/operational_viewpoint.sysml +1 -1
  99. package/src/viewpoints/physical/physical_viewpoint.sysml +1 -1
  100. package/src/viewpoints/rendering/memo_rendering.sysml +3 -0
  101. package/src/viewpoints/requirements/requirements_viewpoint.sysml +1 -1
  102. package/src/viewpoints/risk/risk_viewpoint.sysml +1 -1
  103. package/src/viewpoints/software/software_viewpoint.sysml +1 -1
  104. package/src/viewpoints/stakeholders_concerns/memo_stakeholders_concerns.sysml +30 -35
  105. package/src/viewpoints/ui_layout/ui_layout_viewpoint.sysml +1 -1
  106. package/src/viewpoints/ui_layout/views/screen_layout_view/screen_layout_view.sysml +1 -1
  107. package/src/viewpoints/usability/usability_viewpoint.sysml +1 -1
  108. package/src/viewpoints/usability/views/usability_engineering_view/usability_engineering_view.sysml +2 -0
  109. package/src/viewpoints/verification/verification_viewpoint.sysml +1 -1
  110. package/stage1/opensysml-9137d7e2c25cb101df40f875.json.gz +0 -0
  111. package/stage1/syside-fad9dd5987acf384b8552cff.ids.gz +0 -0
  112. package/stage1/syside-fad9dd5987acf384b8552cff.json.gz +0 -0
  113. package/stage1/opensysml-36b29604b1a0eee4ecf3757b.json.gz +0 -0
  114. package/stage1/syside-5246cc20257a6cf7dd9cdc0f.ids.gz +0 -0
  115. package/stage1/syside-5246cc20257a6cf7dd9cdc0f.json.gz +0 -0
@@ -111,6 +111,7 @@ package memo_architecture_implementation_ui {
111
111
  }
112
112
 
113
113
  part def UserInterface specializes MemoPart {
114
+ @MemoIdentity { :>> label = "User interface"; }
114
115
  attribute modality : String;
115
116
  attribute uiTechnology : String;
116
117
  }
@@ -143,6 +144,7 @@ package memo_architecture_implementation_ui {
143
144
  // SoftwareComponent, code is SoftwareModule, and the UI is a third view of
144
145
  // the same software — a sibling of those, not a kind of either.
145
146
  part def UIElement specializes SoftwareElement {
147
+ @MemoIdentity { :>> label = "UI element"; }
146
148
  attribute formKind : UIElementFormKind;
147
149
  // The visible label. Held here rather than on a shared interaction
148
150
  // base: a physical control's label is moulded or printed, and is
@@ -223,6 +225,7 @@ package memo_architecture_implementation_ui {
223
225
  }
224
226
 
225
227
  part def OperatorInterfaceElement specializes PhysicalComponent {
228
+ @MemoIdentity { :>> label = "Operator interface element"; }
226
229
  attribute formKind : OperatorInterfaceFormKind;
227
230
  // actuation (optional; set for actuated forms)
228
231
  attribute actuationForce : String;
@@ -241,6 +244,7 @@ package memo_architecture_implementation_ui {
241
244
  // needs before it can rely on the picture. The screen it depicts is an
242
245
  // ordinary UIElement with formKind = screen.
243
246
  part def ScreenCapture specializes MemoEvidence {
247
+ @MemoIdentity { :>> label = "Screen capture"; }
244
248
  attribute imageUri : String;
245
249
  // Content hash of the image bytes. The screenshot is the evidence, so
246
250
  // it must be tamper-evident: a DHF reference to a mutable file is not
@@ -259,10 +263,12 @@ package memo_architecture_implementation_ui {
259
263
 
260
264
  // UI state is presentation state — distinct from system/device state.
261
265
  part def UIState specializes MemoPart {
266
+ @MemoIdentity { :>> label = "UI state"; }
262
267
  attribute displayedInformation : String;
263
268
  attribute availableActions : String;
264
269
  }
265
270
  part def UIEvent specializes MemoPart {
271
+ @MemoIdentity { :>> label = "UI event"; }
266
272
  attribute eventSource : String;
267
273
  attribute intent : InteractionIntentKind;
268
274
  }
@@ -276,6 +282,7 @@ package memo_architecture_implementation_ui {
276
282
  // The three attributes here are what a UI action adds on top: what the
277
283
  // user meant by it, what came back, and whether it asks first.
278
284
  action def UIAction specializes OperativeAction {
285
+ @MemoIdentity { :>> label = "UI action"; }
279
286
  attribute intent : InteractionIntentKind;
280
287
  attribute feedbackProvided : String;
281
288
  attribute confirmationRequired : Boolean;
@@ -284,6 +291,7 @@ package memo_architecture_implementation_ui {
284
291
  // A reusable dialogue structure through the UI; a selected path through
285
292
  // it is a OperativeScenario with scenarioKind `ui`.
286
293
  action def InteractionFlow specializes MemoAction {
294
+ @MemoIdentity { :>> label = "Interaction flow"; }
287
295
  attribute entryPoint : String;
288
296
  attribute exitPoint : String;
289
297
  }
@@ -297,6 +305,7 @@ package memo_architecture_implementation_ui {
297
305
  // ── Screen layout relations ──────────────────────────────────
298
306
  // Which modelled screen an image is a rendering of.
299
307
  connection def CapturesScreen :> MemoRelationship {
308
+ @MemoIdentity { :>> label = "Captures screen"; }
300
309
  end capture : ScreenCapture :>> source;
301
310
  end screen : UIElement :>> target;
302
311
  }
@@ -319,6 +328,7 @@ package memo_architecture_implementation_ui {
319
328
  // A screen is a UIElement whose `formKind` is `screen`; the end says UIElement because the form is an
320
329
  // attribute, not a subtype.
321
330
  connection def NavigatesTo :> MemoRelationship {
331
+ @MemoIdentity { :>> label = "Navigates to"; }
322
332
  end element : UIElement :>> source;
323
333
  end screen : UIElement :>> target;
324
334
  }
@@ -336,6 +346,7 @@ package memo_architecture_implementation_ui {
336
346
  // MemoPart. CR-MED-111 still holds rendered controls to it, and it is
337
347
  // scoped to UIElement, so the wider end does not weaken the rule.
338
348
  connection def ElementTriggersAction :> MemoRelationship {
349
+ @MemoIdentity { :>> label = "Element triggers action"; }
339
350
  end element : MemoPart :>> source;
340
351
  end triggeredAction : UIAction :>> target;
341
352
  }
@@ -348,6 +359,7 @@ package memo_architecture_implementation_ui {
348
359
  // A UI action invokes a function by native `perform`: write `perform
349
360
  // <systemFunction>;` inside the `UIAction` usage.
350
361
  connection def FlowServesUseCase :> MemoRelationship {
362
+ @MemoIdentity { :>> label = "Flow serves use case"; }
351
363
  end interactionFlow : InteractionFlow :>> source;
352
364
  end useCase : UseCase :>> target;
353
365
  }
@@ -365,6 +377,7 @@ package memo_architecture_implementation_ui {
365
377
  // backwards — not only on a control. Narrowing this to an interaction
366
378
  // base made those unmodellable.
367
379
  connection def ErrorAtElement :> MemoRelationship {
380
+ @MemoIdentity { :>> label = "Error at element"; }
368
381
  attribute :>> isTrace = true;
369
382
  end useError : UseError :>> source;
370
383
  end element : MemoPart :>> target;
@@ -378,6 +391,7 @@ package memo_architecture_implementation_ui {
378
391
  // A risk control implemented by a UI element or by task design
379
392
  // (confirmation dialog, lockout, guarded control).
380
393
  connection def ControlImplementedBy :> MemoRelationship {
394
+ @MemoIdentity { :>> label = "Control implemented by"; }
381
395
  attribute :>> isTrace = true;
382
396
  end riskControl : RiskControlMeasure :>> source;
383
397
  end implementingElement :>> target;
@@ -60,6 +60,7 @@ package memo_architecture_logical_interfaces {
60
60
  // Specializes the standard library interface as well as MEMO's base,
61
61
  // rather than shadowing it — see the note on UseCase.
62
62
  abstract interface def Interface specializes MemoInterface, Interfaces::Interface {
63
+ @MemoIdentity { :>> label = "Interface"; }
63
64
  attribute interfaceKind : InterfaceKind; // what crosses
64
65
  attribute direction : DirectionKind;
65
66
  attribute protocol : String; // "SPI", "CAN", "Ethernet", "REST", "4-20mA"
@@ -82,6 +83,7 @@ package memo_architecture_logical_interfaces {
82
83
  // protocol roles and message flows; ports remain the endpoints that
83
84
  // components actually own.
84
85
  abstract interface def SoftwareInterface specializes Interface {
86
+ @MemoIdentity { :>> label = "Software interface"; }
85
87
  // `default`, not `=`. A bare `=` in a definition BINDS the value, and
86
88
  // a binding cannot be overridden by a usage — which asserted that
87
89
  // every software interface is bidirectional and made a directional one
@@ -98,6 +100,7 @@ package memo_architecture_logical_interfaces {
98
100
  // The kind of item is given by itemKind (data / command / signal / …);
99
101
  // the control-specific fields below apply only when itemKind = command.
100
102
  item def InterfaceItem specializes MemoItem {
103
+ @MemoIdentity { :>> label = "Interface item"; }
101
104
  attribute itemKind : InterfaceItemKind;
102
105
  attribute confidentialityClass : String;
103
106
  attribute integrityClass : String;
@@ -112,14 +115,18 @@ package memo_architecture_logical_interfaces {
112
115
  // from the former logical_interfaces namespace.
113
116
 
114
117
  abstract interface def DataInterface specializes MemoInterface {
118
+ @MemoIdentity { :>> label = "Data interface"; }
115
119
  attribute interfaceKind : InterfaceKind;
116
120
  attribute protocolSemantics : String;
117
121
  }
118
122
  port def DataPort specializes MemoPort {
123
+ @MemoIdentity { :>> label = "Data port"; }
119
124
  attribute interfaceType : String;
120
125
  }
121
- port def SensorPort specializes DataPort { attribute sensorDomain : String; }
122
- port def CommandPort specializes DataPort { attribute commandDomain : String; }
126
+ port def SensorPort specializes DataPort {
127
+ @MemoIdentity { :>> label = "Sensor port"; } attribute sensorDomain : String; }
128
+ port def CommandPort specializes DataPort {
129
+ @MemoIdentity { :>> label = "Command port"; } attribute commandDomain : String; }
123
130
 
124
131
  // An interaction between two component ports, and the properties of that
125
132
  // connection itself: what kind of thing it carries and its timing
@@ -139,6 +146,7 @@ package memo_architecture_logical_interfaces {
139
146
  // AR-EXCH-002 holds the exchange to its ports instead. "Input to X" is relative to a system of interest the
140
147
  // model does not have, so it is a question to ask with X given, not a value on the exchange.
141
148
  interface def ComponentExchange specializes MemoInterface {
149
+ @MemoIdentity { :>> label = "Component exchange"; }
142
150
  attribute exchangeKind : FlowKind;
143
151
  // Connection timing discipline from the source architecture
144
152
  // (e.g. AADL Communication_Properties::Timing — immediate
@@ -153,6 +161,7 @@ package memo_architecture_logical_interfaces {
153
161
  // for why `direction` is native and why `portKind` is declared on both
154
162
  // ports instead of on a base.
155
163
  port def SoftwarePort specializes MemoPort {
164
+ @MemoIdentity { :>> label = "Software port"; }
156
165
  attribute portKind : InterfaceKind;
157
166
  // AADL port category. Sampled vs. queued delivery decides whether a
158
167
  // missed deadline drops a sample or grows a queue, which the timing
@@ -96,6 +96,7 @@ package memo_architecture_logical_structure {
96
96
  // which types are admissible; Composes records the actual links.
97
97
 
98
98
  part def SystemOfSystems specializes LogicalComponent {
99
+ @MemoIdentity { :>> label = "System of systems"; }
99
100
  // Constituent systems are independently operated and independently
100
101
  // managed, collaborating for a capability none delivers alone
101
102
  // (ISO/IEC/IEEE 21841). A connected pump talking to a hospital
@@ -115,6 +116,7 @@ package memo_architecture_logical_structure {
115
116
  }
116
117
 
117
118
  part def System specializes LogicalComponent {
119
+ @MemoIdentity { :>> label = "System"; }
118
120
  attribute systemBoundaryDescription : String;
119
121
  attribute origin : SystemOriginKind[0..1];
120
122
  part system : System[0..*];
@@ -123,6 +125,7 @@ package memo_architecture_logical_structure {
123
125
  }
124
126
 
125
127
  part def Subsystem specializes LogicalComponent {
128
+ @MemoIdentity { :>> label = "Subsystem"; }
126
129
  attribute systemBoundaryDescription : String;
127
130
  part subsystem : Subsystem[0..*];
128
131
  part component : LogicalComponent[0..*];
@@ -134,6 +137,7 @@ package memo_architecture_logical_structure {
134
137
  // claiming independence must still be linked by IndependentOf with its
135
138
  // basis stated.
136
139
  part def LogicalComponent specializes MemoPart {
140
+ @MemoIdentity { :>> label = "Logical component"; }
137
141
  attribute componentRole : ComponentRoleKind;
138
142
  attribute systemType : SystemTypeKind[0..1];
139
143
  attribute responsibility : String;
@@ -155,18 +159,23 @@ package memo_architecture_logical_structure {
155
159
  }
156
160
 
157
161
  // Boundary features and contracts.
158
- port def LogicalPort specializes MemoPort;
162
+ port def LogicalPort specializes MemoPort {
163
+ @MemoIdentity { :>> label = "Logical port"; }
164
+ }
159
165
  interface def LogicalInterface specializes Interface {
166
+ @MemoIdentity { :>> label = "Logical interface"; }
160
167
  attribute contentKind : FlowContentKind;
161
168
  end providerPort : LogicalPort;
162
169
  end consumerPort : ~LogicalPort;
163
170
  }
164
171
  item def LogicalExchangeItem specializes MemoItem {
172
+ @MemoIdentity { :>> label = "Logical exchange item"; }
165
173
  attribute contentKind : FlowContentKind;
166
174
  }
167
175
 
168
176
  // A typed logical connection between two components' ports.
169
177
  connection def LogicalConnector :> MemoRelationship {
178
+ @MemoIdentity { :>> label = "Logical connector"; }
170
179
  attribute :>> isConnector = true;
171
180
  attribute contentKind : FlowContentKind;
172
181
  attribute direction : DirectionKind;
@@ -201,12 +210,14 @@ package memo_architecture_logical_structure {
201
210
  // distinguishable (namespace distinguishability) from the library's own
202
211
  // `payload`, so the payload lives on the ports.
203
212
  abstract flow def LogicalExchange {
213
+ @MemoIdentity { :>> label = "Logical exchange"; }
204
214
  attribute contentKind : FlowContentKind;
205
215
  attribute latencyRequirement : String;
206
216
  }
207
217
 
208
218
  // The concrete exchange a model types its logical flows by; the ends stay untyped for the reason above.
209
219
  flow def LogicalTransfer specializes LogicalExchange {
220
+ @MemoIdentity { :>> label = "Logical transfer"; }
210
221
  end source;
211
222
  end target;
212
223
  }
@@ -215,21 +226,25 @@ package memo_architecture_logical_structure {
215
226
  // and from physical device configuration).
216
227
 
217
228
  part def LogicalBehavior specializes MemoPart {
229
+ @MemoIdentity { :>> label = "Logical behavior"; }
218
230
  attribute behaviorSummary : String;
219
231
  attribute executionSemantics : String;
220
232
  }
221
233
 
222
234
  // Isolation, fault containment, and trust boundaries.
223
235
  part def IsolationBoundary specializes MemoPart {
236
+ @MemoIdentity { :>> label = "Isolation boundary"; }
224
237
  attribute boundaryKind : String;
225
238
  attribute isolationMechanism : String;
226
239
  }
227
240
  part def FaultContainmentRegion specializes MemoPart {
241
+ @MemoIdentity { :>> label = "Fault containment region"; }
228
242
  attribute containmentRationale : String;
229
243
  }
230
244
 
231
245
  // Claimed independence between channels (common-cause defense).
232
246
  connection def IndependentOf :> MemoRelationship {
247
+ @MemoIdentity { :>> label = "Independent of"; }
233
248
  attribute independenceBasis : String;
234
249
  end channel : LogicalComponent :>> source;
235
250
  end otherChannel : LogicalComponent :>> target;
@@ -48,6 +48,7 @@ package memo_architecture_operational_activities {
48
48
  // OperativeActions. Human-factors fields (potentialHarm, severityIfFailed,
49
49
  // perceptualCue …) are optional, meaningful when a User is the performer.
50
50
  action def OperativeAction specializes MemoAction {
51
+ @MemoIdentity { :>> label = "Operative action"; }
51
52
  attribute trigger : String;
52
53
  attribute preCondition : String;
53
54
  attribute postCondition : String;
@@ -71,6 +72,7 @@ package memo_architecture_operational_activities {
71
72
  // Difficulty of a task in a particular context. Associated by typed
72
73
  // references, not inheritance; assessments are evidence-bearing.
73
74
  part def TaskDifficultyAssessment specializes MemoPart {
75
+ @MemoIdentity { :>> label = "Task difficulty assessment"; }
74
76
  attribute overallDifficulty : DemandLevelKind;
75
77
  attribute physicalDemand : DemandLevelKind;
76
78
  attribute cognitiveDemand : DemandLevelKind;
@@ -91,6 +93,7 @@ package memo_architecture_operational_activities {
91
93
  }
92
94
 
93
95
  connection def AssessesDifficulty :> MemoRelationship {
96
+ @MemoIdentity { :>> label = "Assesses difficulty"; }
94
97
  end assessment : TaskDifficultyAssessment :>> source;
95
98
  end task : OperativeAction :>> target;
96
99
  }
@@ -12,6 +12,7 @@ package memo_architecture_operational_context_actors {
12
12
  private import memo_core_common::*;
13
13
  private import memo_core_enumerations::*;
14
14
  abstract part def OperationalParticipant specializes MemoPart {
15
+ @MemoIdentity { :>> label = "Operational participant"; }
15
16
  attribute actorKind : ActorKind;
16
17
  attribute trainingLevel : String;
17
18
  attribute responsibility : String;
@@ -23,6 +24,7 @@ package memo_architecture_operational_context_actors {
23
24
  // (patient / clinician / caregiver / technician / administrator); the
24
25
  // role-specific fields below are set only for the relevant actorKind.
25
26
  part def User specializes OperationalParticipant, MemoResource {
27
+ @MemoIdentity { :>> label = "User"; }
26
28
  attribute userPopulation : String;
27
29
  attribute impairmentConsiderations : String;
28
30
  attribute intendedTraining : String;
@@ -36,5 +38,7 @@ package memo_architecture_operational_context_actors {
36
38
  // An actor that is not the device's user, such as a threat or a person present
37
39
  // who does not use the device. An organization, an external system or a device is
38
40
  // an OperationalEntity. `actor` is a SysML keyword, hence the prefix.
39
- part def MemoActor specializes OperationalParticipant;
41
+ part def MemoActor specializes OperationalParticipant {
42
+ @MemoIdentity { :>> label = "Actor"; }
43
+ }
40
44
  }
@@ -13,11 +13,13 @@ package memo_architecture_operational_context_stakeholders {
13
13
  private import memo_core_relationships::*;
14
14
  private import memo_architecture_operational_context_actors::*;
15
15
  part def ArchitectureDescription specializes MemoPart {
16
+ @MemoIdentity { :>> label = "Architecture description"; }
16
17
  attribute systemOfInterest : String;
17
18
  attribute version : String;
18
19
  }
19
20
 
20
21
  part def ModelKind specializes MemoPart {
22
+ @MemoIdentity { :>> label = "Model kind"; }
21
23
  attribute conventions : String;
22
24
  attribute notationReference : String;
23
25
  }
@@ -25,6 +27,7 @@ package memo_architecture_operational_context_stakeholders {
25
27
  // 42010 correspondence: a rule that must hold between architecture
26
28
  // description elements (e.g. consistency between two views).
27
29
  part def CorrespondenceRule specializes MemoPart {
30
+ @MemoIdentity { :>> label = "Correspondence rule"; }
28
31
  attribute ruleExpression : String;
29
32
  }
30
33
 
@@ -37,6 +40,7 @@ package memo_architecture_operational_context_stakeholders {
37
40
  // IntendedUse a requirement — so that end stays untyped, as DerivesFrom's
38
41
  // driver does. What is governed is always a structural element.
39
42
  connection def Governs :> MemoRelationship {
43
+ @MemoIdentity { :>> label = "Governs"; }
40
44
  attribute governKind : GovernKind;
41
45
  end governor :>> source;
42
46
  end governedElement : MemoPart :>> target;
@@ -18,6 +18,7 @@ package memo_architecture_operational_context_use_context {
18
18
  private import memo_architecture_operational_context_actors::*;
19
19
 
20
20
  part def UseContext specializes MemoPart {
21
+ @MemoIdentity { :>> label = "Use context"; }
21
22
  attribute careSetting : String;
22
23
  attribute environment : String;
23
24
  attribute jurisdiction : String;
@@ -27,6 +28,7 @@ package memo_architecture_operational_context_use_context {
27
28
  // The physical/organizational environment of use (IEC 62366-1 3.20),
28
29
  // separable from the care-setting context so environments are reusable.
29
30
  part def UseEnvironment specializes MemoPart {
31
+ @MemoIdentity { :>> label = "Use environment"; }
30
32
  attribute lighting : String;
31
33
  attribute noise : String;
32
34
  attribute vibration : String;
@@ -50,6 +52,7 @@ package memo_architecture_operational_context_use_context {
50
52
  // this relation and nothing else, so a model's general-purpose edges cannot
51
53
  // leak into the boundary picture.
52
54
  connection def InteractsInContext :> MemoRelationship {
55
+ @MemoIdentity { :>> label = "Interacts in context"; }
53
56
  // Which side of the boundary picture the participant belongs on.
54
57
  attribute contextSide : ContextSideKind;
55
58
  // The verb, as it should read on the edge ("Directs procedure").
@@ -69,6 +72,7 @@ package memo_architecture_operational_context_use_context {
69
72
  // `connect`: write `connection connect <a> to <b>;`, the ordinary untyped
70
73
  // binary connection.
71
74
  connection def AppliesInContext :> MemoRelationship {
75
+ @MemoIdentity { :>> label = "Applies in context"; }
72
76
  end useContext : UseContext :>> source;
73
77
  end subjectElement : MemoPart :>> target;
74
78
  }
@@ -79,6 +83,7 @@ package memo_architecture_operational_context_use_context {
79
83
  :>> baseType = appliesInContextLinks meta SysML::Usage;
80
84
  }
81
85
  connection def SituatedIn :> MemoRelationship {
86
+ @MemoIdentity { :>> label = "Situated in"; }
82
87
  end useContext : UseContext :>> source;
83
88
  end environment : UseEnvironment :>> target;
84
89
  }
@@ -37,6 +37,7 @@ package memo_architecture_operational_scenarios {
37
37
  // same two conditions in words, for what no expression says ("patient assessed"); the constraint
38
38
  // is for one that can be checked.
39
39
  action def OperativeScenario specializes MemoAction, MemoConstrainedOccurrence {
40
+ @MemoIdentity { :>> label = "Operative scenario"; }
40
41
  attribute scenarioKind : ScenarioKind default ScenarioKind::nominal;
41
42
  attribute initialState : String;
42
43
  attribute trigger : String;
@@ -14,6 +14,7 @@ package memo_architecture_operational_structure {
14
14
  // obligation the device's design inputs derive from, and ISO 14971 5.2 asks
15
15
  // for it to be documented as the starting point of risk analysis.
16
16
  requirement def IntendedUse :> MemoMission {
17
+ @MemoIdentity { :>> label = "Intended use"; }
17
18
  attribute indication : String;
18
19
  attribute contraindication : String;
19
20
  attribute patientPopulation : String;
@@ -21,11 +22,13 @@ package memo_architecture_operational_structure {
21
22
  attribute regulatoryClassification : String;
22
23
  }
23
24
  part def OperationalEntity specializes MemoPart {
25
+ @MemoIdentity { :>> label = "Operational entity"; }
24
26
  attribute entityKind : OperationalEntityKind;
25
27
  attribute operationalDomain : String;
26
28
  attribute responsibility : String;
27
29
  }
28
30
  part def OperationalCapability specializes MemoPart {
31
+ @MemoIdentity { :>> label = "Operational capability"; }
29
32
  attribute capabilityLevel : String;
30
33
  attribute preCondition : String;
31
34
  attribute postCondition : String;
@@ -34,6 +37,7 @@ package memo_architecture_operational_structure {
34
37
  // The intended use requires these operational capabilities (ARCADIA:
35
38
  // Mission Requires Capability).
36
39
  connection def RequiresCapability :> MemoRelationship {
40
+ @MemoIdentity { :>> label = "Requires capability"; }
37
41
  end requiringIntendedUse : IntendedUse :>> source;
38
42
  end requiredCapability : OperationalCapability :>> target;
39
43
  }
@@ -48,6 +52,7 @@ package memo_architecture_operational_structure {
48
52
  // on to accomplish the goal). Capability is tied to the use case, not to
49
53
  // individual activities.
50
54
  connection def EnablesUseCase :> MemoRelationship {
55
+ @MemoIdentity { :>> label = "Enables use case"; }
51
56
  end enablingCapability : OperationalCapability :>> source;
52
57
  end enabledUseCase : UseCase :>> target;
53
58
  }
@@ -38,6 +38,7 @@ package memo_architecture_operational_use_cases {
38
38
  // being inherited. The wrapper survives only to carry the display label and
39
39
  // lifecycle status; identity comes from `@MemoIdentity`.
40
40
  abstract use case def UseCase :> MemoUseCase, UseCases::UseCase {
41
+ @MemoIdentity { :>> label = "Use case"; }
41
42
  // Text of this use case's goal; this is not a separate Goal element.
42
43
  attribute goalStatement : String;
43
44
  attribute trigger : String;
@@ -66,11 +67,14 @@ package memo_architecture_operational_use_cases {
66
67
  // CR-ONT-093 keeps the declared type and the subject in agreement. `UseCase` is abstract: a
67
68
  // project states which level each use case is at.
68
69
  use case def ClinicalUseCase :> UseCase {
70
+ @MemoIdentity { :>> label = "Clinical use case"; }
69
71
  }
70
72
  use case def SystemUseCase :> UseCase {
73
+ @MemoIdentity { :>> label = "System use case"; }
71
74
  }
72
75
 
73
76
  connection def Motivates :> MemoRelationship {
77
+ @MemoIdentity { :>> label = "Motivates"; }
74
78
  attribute :>> isTrace = true;
75
79
  end motivatingNeed : Need :>> source;
76
80
  end motivatedUseCase : UseCase :>> target;
@@ -36,6 +36,7 @@ package memo_architecture_operational_workflows {
36
36
  private import memo_architecture_operational_use_cases::*;
37
37
 
38
38
  abstract part def OperationalWorkflow specializes MemoPart {
39
+ @MemoIdentity { :>> label = "Operational workflow"; }
39
40
  // Where the body of work starts and ends. A scenario's pre- and
40
41
  // post-conditions are its own path's, inside these.
41
42
  attribute entryCondition : String;
@@ -59,14 +60,17 @@ package memo_architecture_operational_workflows {
59
60
  // `ClinicalWorkflow` realizes a `ClinicalUseCase` (no product, no number); a `SystemWorkflow`
60
61
  // realizes a `SystemUseCase` (one variant, every number). CR-ONT-103 keeps the two in step.
61
62
  part def ClinicalWorkflow specializes OperationalWorkflow {
63
+ @MemoIdentity { :>> label = "Clinical workflow"; }
62
64
  }
63
65
  part def SystemWorkflow specializes OperationalWorkflow {
66
+ @MemoIdentity { :>> label = "System workflow"; }
64
67
  }
65
68
 
66
69
  // The use case a workflow realizes. Many workflows may trace to one use
67
70
  // case; the use case does not own its workflows (the trace points upward,
68
71
  // workflow → use case).
69
72
  connection def RealizesUseCase :> MemoRelationship {
73
+ @MemoIdentity { :>> label = "Realizes use case"; }
70
74
  end realizingWorkflow : OperationalWorkflow :>> source;
71
75
  end realizedUseCase : UseCase :>> target;
72
76
  }
@@ -91,6 +95,7 @@ package memo_architecture_operational_workflows {
91
95
  // or space, by reference. Owned by the workflow as its parts. A staff member is not one: that
92
96
  // is a `User`, which is a `MemoResource` of its own.
93
97
  part def WorkflowResource specializes MemoResource {
98
+ @MemoIdentity { :>> label = "Workflow resource"; }
94
99
  attribute resourceKind : ResourceKind;
95
100
  attribute quantity : Natural;
96
101
  attribute reprocessingDuration : DurationValue[0..1];
@@ -26,6 +26,7 @@ package memo_architecture_realization_deployment {
26
26
  private import memo_architecture_logical_interfaces::*; // ComponentExchange
27
27
 
28
28
  part def SoftwareDeploymentUnit specializes MemoPart {
29
+ @MemoIdentity { :>> label = "Software deployment unit"; }
29
30
  attribute unitKind : String;
30
31
  attribute version : String;
31
32
  attribute integrityProtection : String;
@@ -33,6 +34,7 @@ package memo_architecture_realization_deployment {
33
34
  }
34
35
 
35
36
  part def RuntimeEnvironment specializes MemoPart {
37
+ @MemoIdentity { :>> label = "Runtime environment"; }
36
38
  attribute environmentKind : String;
37
39
  attribute osOrRtos : String;
38
40
  attribute providedServices : String;
@@ -43,6 +45,7 @@ package memo_architecture_realization_deployment {
43
45
  // language has one. Rooted like MemoryBinding / ConnectionBinding below,
44
46
  // so the whole deployment family spells allocation the same way.
45
47
  allocation def BuildsInto :> MemoRelationship, Allocations::Allocation {
48
+ @MemoIdentity { :>> label = "Builds into"; }
46
49
  end module : SoftwareModule :>> source;
47
50
  end deploymentUnit : SoftwareDeploymentUnit :>> target;
48
51
  }
@@ -61,6 +64,7 @@ package memo_architecture_realization_deployment {
61
64
  // architecture, logical as the source. The target is any part, as HostedBy's ends are:
62
65
  // a hardware assembly and a software system are both MemoParts.
63
66
  allocation def RealizedBy :> MemoRelationship, Allocations::Allocation {
67
+ @MemoIdentity { :>> label = "Realized by"; }
64
68
  end logicalComponent : LogicalComponent :>> source;
65
69
  end realization : MemoPart :>> target;
66
70
  }
@@ -72,6 +76,7 @@ package memo_architecture_realization_deployment {
72
76
  }
73
77
  // Written `allocation x : DeploysTo allocate a to b;`.
74
78
  allocation def DeploysTo :> MemoRelationship, Allocations::Allocation {
79
+ @MemoIdentity { :>> label = "Deploys to"; }
75
80
  attribute deploymentKind : DeploymentKind;
76
81
  end deploymentUnit : SoftwareDeploymentUnit :>> source;
77
82
  end node : ProcessingNode :>> target;
@@ -83,6 +88,7 @@ package memo_architecture_realization_deployment {
83
88
  :>> baseType = deploysToLinks meta SysML::Usage;
84
89
  }
85
90
  connection def ProvidesEnvironment :> MemoRelationship {
91
+ @MemoIdentity { :>> label = "Provides environment"; }
86
92
  end node : ProcessingNode :>> source;
87
93
  end environment : RuntimeEnvironment :>> target;
88
94
  }
@@ -113,6 +119,7 @@ package memo_architecture_realization_deployment {
113
119
  // and data occupy — what makes a memory budget a claim about a device
114
120
  // rather than a string.
115
121
  allocation def MemoryBinding :> MemoRelationship, Allocations::Allocation {
122
+ @MemoIdentity { :>> label = "Memory binding"; }
116
123
  attribute bindingKind : String;
117
124
  end boundComponent : SoftwareComponent :>> source;
118
125
  end memory : MemoryDevice :>> target;
@@ -133,6 +140,7 @@ package memo_architecture_realization_deployment {
133
140
  // contributes has to be accounted. Ends are the two bases (MemoInterface,
134
141
  // PhysicalComponent) so one binding serves every layer.
135
142
  allocation def ConnectionBinding :> MemoRelationship, Allocations::Allocation {
143
+ @MemoIdentity { :>> label = "Connection binding"; }
136
144
  attribute allocatedBandwidth : String;
137
145
  attribute mediumLatencyMs : DurationValue;
138
146
  end boundExchange : MemoInterface :>> source;
@@ -161,6 +169,7 @@ package memo_architecture_realization_deployment {
161
169
  }
162
170
  // A flow declared at a logical component boundary (in-port → out-port).
163
171
  part def FlowSpecification specializes MemoPart {
172
+ @MemoIdentity { :>> label = "Flow specification"; }
164
173
  attribute flowKind : FlowSpecKind;
165
174
  ref inPort : LogicalPort[0..1];
166
175
  ref outPort : LogicalPort[0..1];
@@ -169,6 +178,7 @@ package memo_architecture_realization_deployment {
169
178
  // hardware binding it traverses. `latencyBudgetMs` and `analysisPurpose`
170
179
  // (latency | fault-propagation | security) drive the AADL-style analysis.
171
180
  part def EndToEndFlow specializes MemoPart {
181
+ @MemoIdentity { :>> label = "End to end flow"; }
172
182
  attribute latencyBudgetMs : DurationValue;
173
183
  attribute analysisPurpose : String;
174
184
  ref sourceFunction : MemoFunction[0..1];
@@ -181,6 +191,7 @@ package memo_architecture_realization_deployment {
181
191
  // The end-to-end flow is realized by an ordered flow specification, one
182
192
  // segment per traversed component boundary (AADL flow-spec → end-to-end).
183
193
  connection def FlowComprisesSpec :> MemoRelationship {
194
+ @MemoIdentity { :>> label = "Flow comprises spec"; }
184
195
  attribute segmentOrder : Integer;
185
196
  end endToEndFlow : EndToEndFlow :>> source;
186
197
  end spec : FlowSpecification :>> target;
@@ -195,6 +206,7 @@ package memo_architecture_realization_deployment {
195
206
  // A binding IS an allocation, exactly as MemoryBinding and
196
207
  // ConnectionBinding already declare.
197
208
  allocation def FlowTraversesBinding :> MemoRelationship, Allocations::Allocation {
209
+ @MemoIdentity { :>> label = "Flow traverses binding"; }
198
210
  end endToEndFlow : EndToEndFlow :>> source;
199
211
  end deploymentUnit : SoftwareDeploymentUnit :>> target;
200
212
  }
@@ -15,6 +15,7 @@ package memo_architecture_realization_physical {
15
15
  // their nature.
16
16
  private import memo_architecture_implementation_hardware_common::PhysicalElement;
17
17
  part def ProcessingNode specializes PhysicalElement {
18
+ @MemoIdentity { :>> label = "Processing node"; }
18
19
  attribute nodeKind : ProcessingNodeKind;
19
20
  attribute processorArchitecture : String;
20
21
  attribute memoryMB : StorageCapacityValue;
@@ -26,6 +27,7 @@ package memo_architecture_realization_physical {
26
27
  attribute realTimeCapable : Boolean;
27
28
  }
28
29
  part def MemoryDevice specializes PhysicalElement {
30
+ @MemoIdentity { :>> label = "Memory device"; }
29
31
  attribute memoryKind : String;
30
32
  attribute capacityMB : StorageCapacityValue;
31
33
  attribute nonVolatile : Boolean;
@@ -50,6 +52,7 @@ package memo_architecture_realization_physical {
50
52
  // holding one attribute is a class standing in for an attribute. One
51
53
  // attribute, two sites, no new type.
52
54
  port def PhysicalPort specializes MemoPort {
55
+ @MemoIdentity { :>> label = "Physical port"; }
53
56
  attribute portKind : InterfaceKind;
54
57
  // AADL port category — see SoftwarePort. A physical port carries it for
55
58
  // the same reason: a sampled sensor line and a queued interrupt line
@@ -93,6 +96,7 @@ package memo_architecture_realization_physical {
93
96
  // allocation cbMotorDrive : ConnectionBinding
94
97
  // allocate cnMotorDrive to motorHarness;
95
98
  interface def PhysicalInterface specializes Interface {
99
+ @MemoIdentity { :>> label = "Physical interface"; }
96
100
  // analog, digital, discrete, pulse or power transfer. Fill in the
97
101
  // descriptors that kind needs: a bit rate and protocol for digital,
98
102
  // a frequency for pulse. An analog signal's range is a constraint on
@@ -111,6 +115,7 @@ package memo_architecture_realization_physical {
111
115
  // What crosses a physical interface, as a quantity: a voltage, a
112
116
  // current, a pressure, a force, a flow of fluid.
113
117
  abstract flow def PhysicalFlow {
118
+ @MemoIdentity { :>> label = "Physical flow"; }
114
119
  attribute quantity : String;
115
120
  attribute unit : String;
116
121
  attribute nominalValue : String;
@@ -118,6 +123,7 @@ package memo_architecture_realization_physical {
118
123
 
119
124
  // The concrete flow a model types its physical flows by; a concrete `flow def` declares its two ends.
120
125
  flow def PhysicalTransfer specializes PhysicalFlow {
126
+ @MemoIdentity { :>> label = "Physical transfer"; }
121
127
  end source;
122
128
  end target;
123
129
  }