@memoarchitect/ontology 0.21.0 → 0.23.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 (60) hide show
  1. package/README.md +1 -1
  2. package/examples/gastric-bypass-variants/model/catalog/gastric_bypass_variants.sysml +17 -17
  3. package/examples/gpca-pump/model/catalog/gpca_operational.sysml +6 -12
  4. package/examples/reusable-instrument/model/catalog/reusable_instrument.sysml +2 -2
  5. package/examples/robot-cell-family/model/catalog/sos/chains.sysml +1 -1
  6. package/examples/robot-cell-family/model/catalog/sos/use_cases.sysml +1 -1
  7. package/examples/robot-cell-family/model/catalog/systems/manipulation/manipulation_system.sysml +1 -1
  8. package/examples/robot-cell-family/model/catalog/systems/navigation/navigation_system.sysml +1 -1
  9. package/examples/robot-cell-family/model/catalog/systems/perception/perception_system.sysml +1 -1
  10. package/examples/surgical-closure-workflow/model/catalog/surgical_closure_workflow.sysml +2 -2
  11. package/examples/sysml-diagram-samples/model/catalog/samples/browser_view.sysml +3 -3
  12. package/examples/sysml-diagram-samples/model/catalog/samples/use_case_view.sysml +5 -5
  13. package/examples/temperature-alarm/model/catalog/temperature_alarm.sysml +1 -1
  14. package/extensions/aadl/memo.package.yaml +1 -1
  15. package/extensions/anatomy/memo.package.yaml +1 -1
  16. package/extensions/clinical/memo.package.yaml +1 -1
  17. package/extensions/cloud/memo.package.yaml +1 -1
  18. package/extensions/container/memo.package.yaml +1 -1
  19. package/extensions/messaging/memo.package.yaml +1 -1
  20. package/extensions/ros/memo.package.yaml +1 -1
  21. package/methodologies/default/memo.package.yaml +1 -1
  22. package/methodologies/gpca/memo.package.yaml +1 -1
  23. package/ontology/memo.package.yaml +1 -1
  24. package/package.json +1 -1
  25. package/profile/memo.package.yaml +1 -1
  26. package/src/architecture/functional/functions/memo_functions.sysml +6 -1
  27. package/src/architecture/operational/rollups/memo_rollups.sysml +3 -3
  28. package/src/architecture/operational/use_cases/memo_use_cases.sysml +4 -4
  29. package/src/architecture/operational/workflows/memo_workflows.sysml +15 -16
  30. package/src/artifacts/templates/dhf/21cfr820/user-needs.md +1 -1
  31. package/src/artifacts/templates/dhf/iec-62366/summative-eval.md +1 -1
  32. package/src/artifacts/templates/dhf/iec-62366/ue-plan.md +1 -1
  33. package/src/artifacts/templates/dhf/iec-62366/urra.md +1 -1
  34. package/src/artifacts/templates/dhf/iec-62366/use-spec.md +1 -1
  35. package/src/assurance/requirements/needs/memo_needs.sysml +1 -1
  36. package/src/core/enumerations/memo_enumerations.sysml +10 -0
  37. package/src/core/relationships/memo_workspace_membership.sysml +4 -1
  38. package/src/methodology/profiles/memo_profiles.sysml +628 -73
  39. package/src/methodology/workflow/memo_workflow.sysml +57 -7
  40. package/src/rules/ontology/ontology_invariants.sysml +58 -14
  41. package/src/viewpoints/catalog/memo_viewpoint_catalog.sysml +28 -28
  42. package/src/viewpoints/clinical_workflow/clinical_workflow_viewpoint.sysml +1 -1
  43. package/src/viewpoints/context/context_viewpoint.sysml +1 -1
  44. package/src/viewpoints/cybersecurity/cybersecurity_viewpoint.sysml +1 -1
  45. package/src/viewpoints/definitions/memo_view_layout.sysml +19 -0
  46. package/src/viewpoints/functional/functional_viewpoint.sysml +1 -1
  47. package/src/viewpoints/logical/logical_viewpoint.sysml +1 -1
  48. package/src/viewpoints/operational/operational_viewpoint.sysml +1 -1
  49. package/src/viewpoints/physical/physical_viewpoint.sysml +1 -1
  50. package/src/viewpoints/requirements/requirements_viewpoint.sysml +1 -1
  51. package/src/viewpoints/risk/risk_viewpoint.sysml +1 -1
  52. package/src/viewpoints/software/software_viewpoint.sysml +1 -1
  53. package/src/viewpoints/usability/usability_viewpoint.sysml +1 -1
  54. package/src/viewpoints/verification/verification_viewpoint.sysml +1 -1
  55. package/stage1/opensysml-ad5ae1d762e9e7107282daa2.json.gz +0 -0
  56. package/stage1/syside-ff96456991e9f3c2ca352a54.ids.gz +0 -0
  57. package/stage1/syside-ff96456991e9f3c2ca352a54.json.gz +0 -0
  58. package/stage1/opensysml-9137d7e2c25cb101df40f875.json.gz +0 -0
  59. package/stage1/syside-fad9dd5987acf384b8552cff.ids.gz +0 -0
  60. package/stage1/syside-fad9dd5987acf384b8552cff.json.gz +0 -0
@@ -8,6 +8,18 @@ package memo_methodology_profiles {
8
8
  private import memo_methodology_gates::*;
9
9
  private import memo_rules_closure::*;
10
10
  private import memo_viewpoints_catalog::*;
11
+ private import memo_viewpoints_context_context_viewpoint::*;
12
+ private import memo_viewpoints_operational_operational_viewpoint::*;
13
+ private import memo_viewpoints_functional_functional_viewpoint::*;
14
+ private import memo_viewpoints_logical_logical_viewpoint::*;
15
+ private import memo_viewpoints_software_software_viewpoint::*;
16
+ private import memo_viewpoints_physical_physical_viewpoint::*;
17
+ private import memo_viewpoints_requirements_requirements_viewpoint::*;
18
+ private import memo_viewpoints_risk_risk_viewpoint::*;
19
+ private import memo_viewpoints_cybersecurity_cybersecurity_viewpoint::*;
20
+ private import memo_viewpoints_usability_usability_viewpoint::*;
21
+ private import memo_viewpoints_verification_verification_viewpoint::*;
22
+
11
23
  private import memo_viewpoints_stakeholders_concerns::*;
12
24
  private import memo_core_enumerations::*;
13
25
  private import memo_core_methodology_scope::*;
@@ -15,7 +27,7 @@ package memo_methodology_profiles {
15
27
  private import memo_core_common::*;
16
28
  part mdCoreLibrary : MethodologyLibrary {
17
29
  @MemoIdentity { :>> providedId = "METHLIB-001"; :>> label = "MedicalDeviceMethodologyLibrary"; }
18
- attribute :>> version = "0.21.0";
30
+ attribute :>> version = "0.23.0";
19
31
  attribute :>> domain = "medical device modeling";
20
32
  doc /* Methodology layer for selecting, restricting, sequencing, tailoring, and lightly extending use of the medical-device ontology. */
21
33
  }
@@ -36,7 +48,7 @@ package memo_methodology_profiles {
36
48
  // second scope authority.
37
49
  part mdDefaultDefinition : MethodologyDefinition {
38
50
  @MemoIdentity { :>> providedId = "METH-MD-DEFAULT"; :>> label = "MedicalDeviceDefault"; }
39
- attribute :>> version = "0.21.0";
51
+ attribute :>> version = "0.23.0";
40
52
  attribute :>> domain = "medical device modeling";
41
53
  doc /* MEMO default medical-device methodology. Selects every layer, discipline, standard, artifact kind, and viewpoint the resolved ontology and extension packages provide. */
42
54
  attribute :>> scopeMode = ScopeModeKind::allAvailable;
@@ -70,186 +82,701 @@ package memo_methodology_profiles {
70
82
  attribute :>> strength = RuleStrengthKind::required;
71
83
  }
72
84
 
73
- // The default method: the steps a family works through, at the system of
74
- // systems and at each system. `outputKinds` and the rules a step is
75
- // `#DoneWhen` say when its own work is done; the rules it is `#LinkedWhen`
76
- // say when it is linked to the other layers.
85
+ // The default method: the rows of the method map, and the steps a family works through in
86
+ // each, at the system of systems and at each system. A step's label is what it asks for, as a verb
87
+ // phrase; `objectiveDescription` says how; `exitCriteria` says when it is done. `outputKinds` and the
88
+ // rules a step is `#DoneWhen` say when its own work is done; the rules it is `#LinkedWhen` say when it is
89
+ // linked to the other layers. Teams start in any row; nothing waits for anything.
90
+
91
+ // ── The rows of the method map ───────────────────────────────────────────
92
+
93
+ part layerContext : MethodLayer {
94
+ attribute :>> elementKinds = ("OperationalParticipant", "User", "MemoActor", "OperationalEntity", "IntendedUse", "UseContext", "UseEnvironment");
95
+ @MemoIdentity { :>> providedId = "ROW-ARC-0"; :>> label = "Context"; }
96
+ doc /* Who and what is around it: users, organizations, external systems. */
97
+ attribute :>> axis = MethodAxisKind::architecture;
98
+ attribute :>> stages = (WorkflowStageKind::context);
99
+ ref :>> layerViewpoints = (vpSystemContext, contextViewpoint);
100
+ }
101
+ part taskClinicalWork : MethodWorkTask {
102
+ @MemoIdentity { :>> label = "Clinical"; }
103
+ attribute :>> taskKind = MethodTaskKind::decomposition;
104
+ attribute :>> primary = true;
105
+ attribute :>> taskLevel = "clinical";
106
+ attribute :>> taskSubjectKind = "ClinicalUseCase";
107
+ attribute :>> taskWorkflowKind = "ClinicalWorkflow";
108
+ attribute :>> taskScenarioKind = "OperativeScenario";
109
+ attribute :>> taskStepKind = "OperativeAction";
110
+ attribute :>> taskRelationshipKind = "realizesUseCase";
111
+ attribute :>> objectiveDescription = "Describe clinical goals and the workflows, scenarios and steps that achieve them, independently of a product.";
112
+ attribute :>> reviewDescription = "Review each goal, its workflows, nominal and alternate paths, and the steps in each path.";
113
+ ref :>> taskViewpoint = vpScenario;
114
+ }
115
+ part taskOperationalWork : MethodWorkTask {
116
+ @MemoIdentity { :>> label = "Operational"; }
117
+ attribute :>> taskKind = MethodTaskKind::decomposition;
118
+ attribute :>> primary = true;
119
+ attribute :>> taskLevel = "operational";
120
+ attribute :>> taskSubjectKind = "OperationalUseCase";
121
+ attribute :>> taskWorkflowKind = "OperationalWorkflow";
122
+ attribute :>> taskScenarioKind = "OperativeScenario";
123
+ attribute :>> taskStepKind = "OperativeAction";
124
+ attribute :>> taskRelationshipKind = "realizesUseCase";
125
+ attribute :>> objectiveDescription = "Describe how the work is done with this system: its goals, workflows, scenarios and activities. Each activity realizes a clinical step and is realized by functions.";
126
+ attribute :>> reviewDescription = "Review each goal, its workflows, nominal and alternate paths, and the steps in each path.";
127
+ ref :>> taskViewpoint = vpScenario;
128
+ }
129
+ part layerOperational : MethodLayer {
130
+ attribute :>> workbench = "operational";
131
+ ref :>> workTasks = (taskClinicalWork, taskOperationalWork);
132
+ attribute :>> elementKinds = ("OperativeAction", "TaskDifficultyAssessment", "OperationalParticipant", "User", "MemoActor", "ArchitectureDescription", "ModelKind", "CorrespondenceRule", "UseContext", "UseEnvironment", "OperativeScenario", "IntendedUse", "OperationalEntity", "OperationalCapability", "UseCase", "ClinicalUseCase", "OperationalUseCase", "Workflow", "ClinicalWorkflow", "OperationalWorkflow", "WorkflowResource");
133
+ @MemoIdentity { :>> providedId = "ROW-ARC-1"; :>> label = "Operational"; }
134
+ doc /* What users need to accomplish. */
135
+ attribute :>> axis = MethodAxisKind::architecture;
136
+ attribute :>> stages = (WorkflowStageKind::operational);
137
+ ref :>> layerViewpoints = (vpUseCase, vpClinicalWorkflow, vpScenario, operationalViewpoint);
138
+ }
139
+ part taskFunctionalTree : MethodWorkTask {
140
+ @MemoIdentity { :>> label = "Functional tree"; }
141
+ attribute :>> taskKind = MethodTaskKind::decomposition;
142
+ attribute :>> primary = true;
143
+ attribute :>> taskSubjectKind = "SystemFunction";
144
+ attribute :>> objectiveDescription = "Break down what this system must do. Select a function to review its purpose and realization.";
145
+ attribute :>> reviewDescription = "Review the functional breakdown and functions that still need realization.";
146
+ ref :>> taskViewpoint = vpFunctionalArchitecture;
147
+ }
148
+ part taskFunctionalFlows : MethodWorkTask {
149
+ @MemoIdentity { :>> label = "Functional flows"; }
150
+ attribute :>> taskKind = MethodTaskKind::sequence;
151
+ attribute :>> primary = true;
152
+ attribute :>> taskSubjectKind = "FunctionalFlow";
153
+ attribute :>> taskReferenceKind = "SystemFunction";
154
+ attribute :>> taskRelationshipKind = "performs";
155
+ attribute :>> objectiveDescription = "Describe a path through the system functions. Reuse the functions in the tree; a flow step calls a function.";
156
+ attribute :>> reviewDescription = "Review the steps, their order and the system functions they call.";
157
+ ref :>> taskViewpoint = vpFunctionalFlow;
158
+ }
159
+ part taskFunctionRealization : MethodWorkTask {
160
+ @MemoIdentity { :>> label = "Realization and allocation"; }
161
+ attribute :>> taskKind = MethodTaskKind::realization;
162
+ attribute :>> primary = false;
163
+ attribute :>> taskSubjectKind = "SystemFunction";
164
+ attribute :>> taskImplementationKind = "ComponentFunction";
165
+ attribute :>> taskAllocationKind = "LogicalComponent";
166
+ attribute :>> taskRelationshipKind = "realizes";
167
+ attribute :>> objectiveDescription = "Realize a system function with component functions. Allocate each component function to the component responsible for it.";
168
+ attribute :>> reviewDescription = "Review the system function, its realizing component functions and their allocated components.";
169
+ ref :>> taskViewpoint = vpFunctionalArchitecture;
170
+ }
171
+ part layerFunctional : MethodLayer {
172
+ attribute :>> workbench = "functional";
173
+ ref :>> workTasks = (taskFunctionalTree, taskFunctionalFlows, taskFunctionRealization);
174
+ attribute :>> elementKinds = ("StateMachine", "ModeConfiguration", "BehaviorProperty", "Contract", "TimingConstraint", "MemoFunction", "SystemFunction", "ComponentFunction", "FunctionalExchange", "FunctionalTransfer", "FunctionalFlow");
175
+ @MemoIdentity { :>> providedId = "ROW-ARC-2"; :>> label = "Functional"; }
176
+ doc /* What the system has to accomplish. */
177
+ attribute :>> axis = MethodAxisKind::architecture;
178
+ attribute :>> stages = (WorkflowStageKind::functional);
179
+ ref :>> layerViewpoints = (vpFunctionalArchitecture, vpFunctionalFlow, vpStateMode, functionalViewpoint);
180
+ }
181
+ part layerLogical : MethodLayer {
182
+ attribute :>> elementKinds = ("DesignDecision", "ComponentFunction", "Interface", "SoftwareInterface", "InterfaceItem", "DataInterface", "DataPort", "SensorPort", "CommandPort", "ComponentExchange", "SoftwarePort", "SystemOfSystems", "System", "Subsystem", "LogicalComponent", "LogicalPort", "LogicalInterface", "LogicalExchangeItem", "LogicalExchange", "LogicalTransfer", "LogicalBehavior", "IsolationBoundary", "FaultContainmentRegion");
183
+ @MemoIdentity { :>> providedId = "ROW-ARC-3"; :>> label = "Logical"; }
184
+ doc /* How the system will work. */
185
+ attribute :>> axis = MethodAxisKind::architecture;
186
+ attribute :>> stages = (WorkflowStageKind::logical);
187
+ ref :>> layerViewpoints = (vpLogicalArchitecture, vpInternalInterconnection, vpSequenceInteraction, vpStateMode, logicalArchitectureViewpoint);
188
+ }
189
+ part layerImplementation : MethodLayer {
190
+ attribute :>> elementKinds = ("PhysicalElement", "PhysicalAssembly", "PhysicalSubassembly", "HardwareAssembly", "PhysicalComponent", "HardwareComponent", "AcousticComponent", "ThermalComponent", "ElectricalComponent", "ElectronicComponent", "PowerSupply", "Battery", "Cable", "PhysicalConnectorPart", "NetworkMedium", "FluidicComponent", "PneumaticComponent", "MechanicalPart", "Enclosure", "OpticalComponent", "Sensor", "Actuator", "SoftwareComponent", "OTSSoftwareComponent", "SoftwareElement", "SoftwareSystem", "SoftwareModule", "Algorithm", "DataModel", "ConfigurationArtifact", "DataItem", "SOUPSoftwareModule", "OTSSoftwareModule", "SBOMEntry", "SoftwareBillOfMaterials", "UserInterface", "UIElement", "OperatorInterfaceElement", "ScreenCapture", "UIState", "UIEvent", "UIAction", "InteractionFlow");
191
+ @MemoIdentity { :>> providedId = "ROW-ARC-4"; :>> label = "Implementation"; }
192
+ doc /* How it is built. */
193
+ attribute :>> axis = MethodAxisKind::architecture;
194
+ attribute :>> stages = (WorkflowStageKind::implementation);
195
+ ref :>> layerViewpoints = (vpSoftwareComponents, vpHardwareArchitecture, vpUILayout, softwareViewpoint);
196
+ }
197
+ part layerRealization : MethodLayer {
198
+ attribute :>> elementKinds = ("SoftwareDeploymentUnit", "RuntimeEnvironment", "FlowSpecification", "EndToEndFlow", "ProcessingNode", "MemoryDevice", "PhysicalPort", "PhysicalInterface", "PhysicalFlow", "PhysicalTransfer");
199
+ @MemoIdentity { :>> providedId = "ROW-ARC-5"; :>> label = "Realization"; }
200
+ doc /* How it is assembled and deployed. */
201
+ attribute :>> axis = MethodAxisKind::architecture;
202
+ attribute :>> stages = (WorkflowStageKind::realization);
203
+ ref :>> layerViewpoints = (vpPhysicalArchitecture, vpNetworkDeployment, physicalViewpoint);
204
+ }
205
+ part disciplineRequirements : MethodLayer {
206
+ attribute :>> elementKinds = ("ProductFeature", "RiskDriver", "Requirement", "SystemConstant", "NotificationSpec", "Need");
207
+ @MemoIdentity { :>> providedId = "ROW-ASR-1"; :>> label = "Requirements"; }
208
+ doc /* What the device must do, and why. */
209
+ attribute :>> axis = MethodAxisKind::assurance;
210
+ attribute :>> stages = (WorkflowStageKind::requirements);
211
+ ref :>> layerViewpoints = (vpRequirementsTraceability, requirementsViewpoint);
212
+ attribute :>> linkDescription = "needs from Operational · satisfied by Functional and Logical";
213
+ attribute :>> importable = true;
214
+ }
215
+ part disciplineSafetyRisk : MethodLayer {
216
+ attribute :>> elementKinds = ("FMEAWorksheet", "FailureMode", "FailureEffect", "FailureCause", "DetectionMethod", "FMEAAction", "FaultTree", "FaultTreeNode", "MinimalCutSet", "HAZOPStudy", "HAZOPNode", "HAZOPDeviation", "ReasonablyForeseeableMisuse", "Risk", "ResidualRisk", "RiskMatrix", "SafetyRelatedCharacteristic", "RiskItem", "Hazard", "SequenceOfEvents", "HazardCause", "HazardousSituation", "Harm", "RiskControlMeasure", "Benefit", "OverallResidualRiskEvaluation", "PostMarketSurveillance");
217
+ @MemoIdentity { :>> providedId = "ROW-ASR-2"; :>> label = "Safety and risk"; }
218
+ doc /* What can go wrong, and how it is controlled. */
219
+ attribute :>> axis = MethodAxisKind::assurance;
220
+ attribute :>> stages = (WorkflowStageKind::risk);
221
+ ref :>> layerViewpoints = (vpRiskChain, riskViewpoint);
222
+ attribute :>> standardReference = "ISO 14971";
223
+ attribute :>> linkDescription = "hazards from Operational scenarios · failure modes in Functional · controls placed in Logical and Implementation";
224
+ attribute :>> importable = true;
225
+ }
226
+ part disciplineCybersecurity : MethodLayer {
227
+ attribute :>> elementKinds = ("CybersecurityAsset", "AttackSurface", "Threat", "Vulnerability", "CyberHazard", "CyberRisk", "CyberMitigation", "SecurityRequirement", "TrustBoundary", "ThreatActor", "AttackTechnique", "SecurityProperty", "CybersecurityAssumption", "AttackPath", "SecurityAssessmentCase", "SecurityFinding", "SecurityAssessmentReport", "PostmarketProcess", "CyberRiskAssessment");
228
+ @MemoIdentity { :>> providedId = "ROW-ASR-3"; :>> label = "Cybersecurity"; }
229
+ doc /* What can be attacked, and how it is mitigated. */
230
+ attribute :>> axis = MethodAxisKind::assurance;
231
+ attribute :>> stages = (WorkflowStageKind::security);
232
+ ref :>> layerViewpoints = (vpCybersecurity, cybersecurityViewpoint);
233
+ attribute :>> linkDescription = "trust boundaries in Logical · SOUP and SBOM in Implementation · exposed assets in Realization";
234
+ }
235
+ part disciplineHumanFactors : MethodLayer {
236
+ attribute :>> elementKinds = ("UseError");
237
+ @MemoIdentity { :>> providedId = "ROW-ASR-4"; :>> label = "Human factors"; }
238
+ doc /* How people use it safely. */
239
+ attribute :>> axis = MethodAxisKind::assurance;
240
+ attribute :>> stages = (WorkflowStageKind::humanFactors);
241
+ ref :>> layerViewpoints = (vpHumanFactors, vpUiFlow, usabilityViewpoint);
242
+ attribute :>> standardReference = "IEC 62366-1";
243
+ attribute :>> linkDescription = "use errors in Operational tasks · screens in Implementation";
244
+ }
245
+ part disciplineVerification : MethodLayer {
246
+ attribute :>> elementKinds = ("ClinicalEvaluation", "TestStep", "VerificationCase", "TestRun", "ValidationCase");
247
+ @MemoIdentity { :>> providedId = "ROW-ASR-5"; :>> label = "Verification and validation"; }
248
+ doc /* How we know it works, and the evidence. */
249
+ attribute :>> axis = MethodAxisKind::assurance;
250
+ attribute :>> stages = (WorkflowStageKind::verificationStage);
251
+ ref :>> layerViewpoints = (vpVerificationCoverage, vpValidationCoverage, vpEvidenceTraceability, verificationViewpoint);
252
+ attribute :>> linkDescription = "verifies requirements, functions, interfaces and controls · validates the use in Operational";
253
+ attribute :>> importable = true;
254
+ }
255
+
256
+ // ── The system of systems ────────────────────────────────────────────────
77
257
 
78
258
  action stepSosContext : MethodologyWorkflowStep {
79
- @MemoIdentity { :>> providedId = "STEP-SOS-01"; :>> label = "SosContext"; }
259
+ @MemoIdentity { :>> providedId = "STEP-SOS-01"; :>> label = "Declare the systems"; }
80
260
  attribute :>> stage = WorkflowStageKind::context;
81
261
  attribute :>> level = MethodLevelKind::systemOfSystems;
82
262
  ref :>> role = projectLead;
83
263
  ref :>> guideViewpoint = vpSystemContext;
84
264
  attribute :>> outputKinds = ("SystemOfSystems", "System");
85
- attribute :>> objectiveDescription = "State the system of systems and the systems it is made of.";
265
+ attribute :>> objectiveDescription = "State the system of systems and the systems it is made of, to any depth.";
86
266
  attribute :>> entryCriteria = "The family is chosen.";
87
267
  attribute :>> exitCriteria = "The system of systems and its constituent systems are declared.";
88
268
  }
89
269
 
90
- action stepSosOperational : MethodologyWorkflowStep {
91
- @MemoIdentity { :>> providedId = "STEP-SOS-02"; :>> label = "SosOperationalAnalysis"; }
270
+ action stepSosUsers : MethodologyWorkflowStep {
271
+ @MemoIdentity { :>> providedId = "STEP-SOS-02"; :>> label = "Name the users and the people around them"; }
272
+ attribute :>> stage = WorkflowStageKind::context;
273
+ attribute :>> level = MethodLevelKind::systemOfSystems;
274
+ ref :>> role = systemArchitect;
275
+ ref :>> guideViewpoint = vpSystemContext;
276
+ attribute :>> outputKinds = ("User");
277
+ attribute :>> objectiveDescription = "Name who uses the systems together: clinicians, patients, service staff. Stakeholders are kept apart from the users.";
278
+ attribute :>> entryCriteria = "Nothing: start here if you know who uses it.";
279
+ attribute :>> exitCriteria = "Each user group is named.";
280
+ }
281
+
282
+ action stepSosUseCases : MethodologyWorkflowStep {
283
+ @MemoIdentity { :>> providedId = "STEP-SOS-03"; :>> label = "State the clinical goals"; }
92
284
  attribute :>> stage = WorkflowStageKind::operational;
93
285
  attribute :>> level = MethodLevelKind::systemOfSystems;
94
286
  ref :>> role = systemArchitect;
95
287
  ref :>> guideViewpoint = vpUseCase;
96
- attribute :>> outputKinds = ("UseCase", "OperationalWorkflow");
97
- attribute :>> objectiveDescription = "Describe the clinical procedures the systems serve together, and the workflows that realize them.";
98
- attribute :>> entryCriteria = "The constituent systems are declared.";
288
+ attribute :>> outputKinds = ("UseCase");
289
+ attribute :>> objectiveDescription = "State the clinical indications and procedures the systems serve together, each as one goal.";
290
+ attribute :>> entryCriteria = "Nothing: start here if you know the procedures.";
291
+ attribute :>> exitCriteria = "Each clinical procedure is a use case.";
292
+ }
293
+
294
+ action stepSosOperational : MethodologyWorkflowStep {
295
+ @MemoIdentity { :>> providedId = "STEP-SOS-04"; :>> label = "Analyse the clinical workflows"; }
296
+ attribute :>> stage = WorkflowStageKind::operational;
297
+ attribute :>> level = MethodLevelKind::systemOfSystems;
298
+ ref :>> role = systemArchitect;
299
+ ref :>> guideViewpoint = vpClinicalWorkflow;
300
+ attribute :>> outputKinds = ("Workflow");
301
+ attribute :>> objectiveDescription = "For each procedure, say who takes part, where, with what, and what they need.";
302
+ attribute :>> entryCriteria = "A clinical goal helps; a workflow may come first.";
99
303
  attribute :>> exitCriteria = "Each clinical procedure has a workflow.";
100
304
  }
101
305
 
102
306
  action stepSosFunctions : MethodologyWorkflowStep {
103
- @MemoIdentity { :>> providedId = "STEP-SOS-03"; :>> label = "SosFunctionsAndChains"; }
307
+ @MemoIdentity { :>> providedId = "STEP-SOS-05"; :>> label = "Follow the functions across the systems"; }
104
308
  attribute :>> stage = WorkflowStageKind::functional;
105
309
  attribute :>> level = MethodLevelKind::systemOfSystems;
106
310
  ref :>> role = systemArchitect;
107
311
  ref :>> guideViewpoint = vpFunctionalFlow;
108
312
  attribute :>> outputKinds = ("FunctionalFlow");
109
- attribute :>> objectiveDescription = "Follow the functions across the systems in functional chains.";
110
- attribute :>> entryCriteria = "Clinical procedures and workflows exist.";
313
+ attribute :>> objectiveDescription = "Give the system of systems one explicit parent function, then follow its responsibilities across the constituent systems in functional chains.";
314
+ attribute :>> entryCriteria = "Clinical procedures and workflows help.";
111
315
  attribute :>> exitCriteria = "Each cross-system chain is stated.";
112
316
  }
113
317
 
114
318
  action stepSosArchitecture : MethodologyWorkflowStep {
115
- @MemoIdentity { :>> providedId = "STEP-SOS-04"; :>> label = "SosArchitecture"; }
116
- attribute :>> stage = WorkflowStageKind::architecture;
319
+ @MemoIdentity { :>> providedId = "STEP-SOS-06"; :>> label = "Define the interfaces between the systems"; }
320
+ attribute :>> stage = WorkflowStageKind::logical;
117
321
  attribute :>> level = MethodLevelKind::systemOfSystems;
118
322
  ref :>> role = systemArchitect;
119
323
  ref :>> guideViewpoint = vpSystemDecomposition;
120
324
  attribute :>> outputKinds = ("Interface");
121
- attribute :>> objectiveDescription = "Define the interfaces between the systems.";
122
- attribute :>> entryCriteria = "Functional chains exist.";
325
+ attribute :>> objectiveDescription = "Give each pair of systems that exchange something an interface.";
326
+ attribute :>> entryCriteria = "The systems are declared.";
123
327
  attribute :>> exitCriteria = "Each pair of systems that exchange something has an interface.";
124
328
  }
125
329
 
126
330
  action stepSosHazards : MethodologyWorkflowStep {
127
- @MemoIdentity { :>> providedId = "STEP-SOS-05"; :>> label = "SosHazards"; }
331
+ @MemoIdentity { :>> providedId = "STEP-SOS-07"; :>> label = "Identify the hazards of the systems together"; }
128
332
  attribute :>> stage = WorkflowStageKind::risk;
129
333
  attribute :>> level = MethodLevelKind::systemOfSystems;
130
334
  ref :>> role = safetyEngineer;
131
335
  ref :>> guideViewpoint = vpRiskChain;
336
+ attribute :>> inputKinds = ("OperativeScenario");
132
337
  attribute :>> outputKinds = ("Hazard");
133
- attribute :>> objectiveDescription = "Identify the hazards that arise only from the systems working together.";
134
- attribute :>> entryCriteria = "The architecture and its interfaces exist.";
338
+ attribute :>> objectiveDescription = "Identify the hazards that arise only from the systems working together, and control each.";
339
+ attribute :>> entryCriteria = "The systems and their interfaces help.";
135
340
  attribute :>> exitCriteria = "Each hazard of the combination has a control.";
136
341
  }
137
342
  #LinkedWhen dependency from stepSosHazards to memo_rules_closure::HazardMitigationRule;
138
343
 
344
+ // ── One system: context and the architecture ─────────────────────────────
345
+
346
+ action stepSysUsers : MethodologyWorkflowStep {
347
+ @MemoIdentity { :>> providedId = "STEP-SYS-01"; :>> label = "Name the users"; }
348
+ attribute :>> stage = WorkflowStageKind::context;
349
+ attribute :>> level = MethodLevelKind::system;
350
+ ref :>> role = systemArchitect;
351
+ ref :>> guideViewpoint = vpSystemContext;
352
+ attribute :>> outputKinds = ("User");
353
+ attribute :>> objectiveDescription = "Name the people who use the system, kept apart from the stakeholders who have a say in it.";
354
+ attribute :>> entryCriteria = "Nothing: start here.";
355
+ attribute :>> exitCriteria = "Each user group is named.";
356
+ }
357
+
358
+ action stepSysUseContext : MethodologyWorkflowStep {
359
+ @MemoIdentity { :>> providedId = "STEP-SYS-02"; :>> label = "Describe where it is used"; }
360
+ attribute :>> stage = WorkflowStageKind::context;
361
+ attribute :>> level = MethodLevelKind::system;
362
+ ref :>> role = systemArchitect;
363
+ ref :>> guideViewpoint = vpSystemContext;
364
+ attribute :>> outputKinds = ("UseContext");
365
+ attribute :>> objectiveDescription = "Describe the places and conditions the system is used in, and the external systems it works with.";
366
+ attribute :>> entryCriteria = "Nothing: start here.";
367
+ attribute :>> exitCriteria = "Each place of use is described.";
368
+ }
369
+
139
370
  action stepSysOperational : MethodologyWorkflowStep {
140
- @MemoIdentity { :>> providedId = "STEP-SYS-01"; :>> label = "SystemOperational"; }
371
+ @MemoIdentity { :>> providedId = "STEP-SYS-03"; :>> label = "State what the system is used for"; }
141
372
  attribute :>> stage = WorkflowStageKind::operational;
142
373
  attribute :>> level = MethodLevelKind::system;
143
374
  ref :>> role = systemArchitect;
144
375
  ref :>> guideViewpoint = vpUseCase;
145
376
  attribute :>> outputKinds = ("UseCase");
146
- attribute :>> objectiveDescription = "State what the system is used for.";
147
- attribute :>> entryCriteria = "The system is declared.";
377
+ attribute :>> objectiveDescription = "State each use of the system as one goal. Group goals by including smaller ones; a goal is never a step.";
378
+ attribute :>> entryCriteria = "Nothing: start here.";
148
379
  attribute :>> exitCriteria = "Each use of the system is a use case.";
149
380
  }
150
381
 
382
+ action stepSysWorkflows : MethodologyWorkflowStep {
383
+ @MemoIdentity { :>> providedId = "STEP-SYS-04"; :>> label = "Analyse the work in workflows"; }
384
+ attribute :>> stage = WorkflowStageKind::operational;
385
+ attribute :>> level = MethodLevelKind::system;
386
+ ref :>> role = systemArchitect;
387
+ ref :>> guideViewpoint = vpClinicalWorkflow;
388
+ attribute :>> outputKinds = ("Workflow");
389
+ attribute :>> objectiveDescription = "For each body of work, say who takes part, where, with what equipment, and what they need. Steps go in scenarios.";
390
+ attribute :>> entryCriteria = "A use case helps; the workflow may come first.";
391
+ attribute :>> exitCriteria = "Each use case is realized by a workflow.";
392
+ }
393
+
394
+ action stepSysScenarios : MethodologyWorkflowStep {
395
+ @MemoIdentity { :>> providedId = "STEP-SYS-05"; :>> label = "Step through the work in scenarios"; }
396
+ attribute :>> stage = WorkflowStageKind::operational;
397
+ attribute :>> level = MethodLevelKind::system;
398
+ ref :>> role = systemArchitect;
399
+ ref :>> guideViewpoint = vpScenario;
400
+ attribute :>> outputKinds = ("OperativeScenario");
401
+ attribute :>> objectiveDescription = "Write the nominal and alternate paths through each workflow, saying who performs each step. An operational activity is realized by functions.";
402
+ attribute :>> entryCriteria = "A workflow helps.";
403
+ attribute :>> exitCriteria = "Each workflow has its nominal scenario.";
404
+ }
405
+
151
406
  action stepSysFunctional : MethodologyWorkflowStep {
152
- @MemoIdentity { :>> providedId = "STEP-SYS-02"; :>> label = "SystemFunctional"; }
407
+ @MemoIdentity { :>> providedId = "STEP-SYS-06"; :>> label = "Name the system functions"; }
153
408
  attribute :>> stage = WorkflowStageKind::functional;
154
409
  attribute :>> level = MethodLevelKind::system;
155
410
  ref :>> role = systemArchitect;
156
411
  ref :>> guideViewpoint = vpFunctionalArchitecture;
157
412
  attribute :>> outputKinds = ("SystemFunction");
158
- attribute :>> objectiveDescription = "State what the system does.";
159
- attribute :>> entryCriteria = "The system use cases exist.";
413
+ attribute :>> objectiveDescription = "Give the system one explicit parent function, then decompose its responsibilities beneath it. Many scenario steps need the same function: link them to one.";
414
+ attribute :>> entryCriteria = "Nothing: start here.";
160
415
  attribute :>> exitCriteria = "Each function is stated.";
161
416
  }
162
417
 
418
+ action stepSysFunctionalExchanges : MethodologyWorkflowStep {
419
+ @MemoIdentity { :>> providedId = "STEP-SYS-07"; :>> label = "Describe what the functions exchange"; }
420
+ attribute :>> stage = WorkflowStageKind::functional;
421
+ attribute :>> level = MethodLevelKind::system;
422
+ ref :>> role = systemArchitect;
423
+ ref :>> guideViewpoint = vpFunctionalFlow;
424
+ attribute :>> outputKinds = ("FunctionalFlow");
425
+ attribute :>> objectiveDescription = "Connect the functions by the data, energy and material they pass to each other.";
426
+ attribute :>> entryCriteria = "Functions exist.";
427
+ attribute :>> exitCriteria = "Each function that needs an input has one.";
428
+ }
429
+
430
+ action stepSysFunctionalChains : MethodologyWorkflowStep {
431
+ @MemoIdentity { :>> providedId = "STEP-SYS-08"; :>> label = "Chain the functions end to end"; }
432
+ attribute :>> stage = WorkflowStageKind::functional;
433
+ attribute :>> level = MethodLevelKind::system;
434
+ ref :>> role = systemArchitect;
435
+ ref :>> guideViewpoint = vpFunctionalFlow;
436
+ attribute :>> objectiveDescription = "A functional chain is the end-to-end path one goal needs; it sets the latency and safety budget.";
437
+ attribute :>> entryCriteria = "Functions exist.";
438
+ attribute :>> exitCriteria = "Each function is in a chain.";
439
+ }
440
+ #DoneWhen dependency from stepSysFunctionalChains to memo_rules_closure::FunctionInChainRule;
441
+
163
442
  action stepSysLogical : MethodologyWorkflowStep {
164
- @MemoIdentity { :>> providedId = "STEP-SYS-03"; :>> label = "SystemLogical"; }
443
+ @MemoIdentity { :>> providedId = "STEP-SYS-09"; :>> label = "Name the logical components"; }
165
444
  attribute :>> stage = WorkflowStageKind::logical;
166
445
  attribute :>> level = MethodLevelKind::system;
167
446
  ref :>> role = systemArchitect;
168
447
  ref :>> guideViewpoint = vpLogicalArchitecture;
169
448
  attribute :>> outputKinds = ("LogicalComponent");
170
- attribute :>> objectiveDescription = "Divide the system into logical components and allocate its functions.";
171
- attribute :>> entryCriteria = "The system functions exist.";
449
+ attribute :>> objectiveDescription = "Divide the system into the parts it is made of, independent of technology.";
450
+ attribute :>> entryCriteria = "Nothing: start here.";
451
+ attribute :>> exitCriteria = "The system is divided into components.";
452
+ }
453
+
454
+ action stepSysComponentFunctions : MethodologyWorkflowStep {
455
+ @MemoIdentity { :>> label = "Define component functions"; }
456
+ attribute :>> stage = WorkflowStageKind::logical;
457
+ attribute :>> level = MethodLevelKind::system;
458
+ ref :>> role = systemArchitect;
459
+ ref :>> guideViewpoint = vpLogicalArchitecture;
460
+ attribute :>> outputKinds = ("ComponentFunction");
461
+ attribute :>> objectiveDescription = "Describe each component's responsibilities beneath the system's parent function. Allocate each component function to exactly one component; show it beside that component in Logical.";
462
+ attribute :>> entryCriteria = "A logical component exists.";
463
+ attribute :>> exitCriteria = "Each component function is allocated to its component.";
464
+ }
465
+ #DoneWhen dependency from stepSysComponentFunctions to memo_rules_ontology::ComponentFunctionAllocatedRule;
466
+
467
+ action stepSysLogicalAllocation : MethodologyWorkflowStep {
468
+ @MemoIdentity { :>> providedId = "STEP-SYS-10"; :>> label = "Give each function to a component"; }
469
+ attribute :>> stage = WorkflowStageKind::logical;
470
+ attribute :>> level = MethodLevelKind::system;
471
+ ref :>> role = systemArchitect;
472
+ ref :>> guideViewpoint = vpLogicalArchitecture;
473
+ attribute :>> objectiveDescription = "Allocate each system function to the one component that performs it. A function split across two components is two functions.";
474
+ attribute :>> entryCriteria = "Functions and components exist; either side may come first.";
172
475
  attribute :>> exitCriteria = "Every function is allocated to a component.";
173
476
  }
174
- #LinkedWhen dependency from stepSysLogical to memo_rules_closure::LogicalFunctionAllocationRule;
477
+ #LinkedWhen dependency from stepSysLogicalAllocation to memo_rules_closure::LogicalFunctionAllocationRule;
175
478
 
176
- action stepSysHardware : MethodologyWorkflowStep {
177
- @MemoIdentity { :>> providedId = "STEP-SYS-04"; :>> label = "SystemHardware"; }
178
- attribute :>> stage = WorkflowStageKind::physical;
479
+ action stepSysLogicalInterfaces : MethodologyWorkflowStep {
480
+ @MemoIdentity { :>> providedId = "STEP-SYS-11"; :>> label = "Connect the components"; }
481
+ attribute :>> stage = WorkflowStageKind::logical;
179
482
  attribute :>> level = MethodLevelKind::system;
180
- ref :>> role = hardwareEngineer;
181
- ref :>> guideViewpoint = vpHardwareArchitecture;
182
- attribute :>> outputKinds = ("PhysicalAssembly");
183
- attribute :>> objectiveDescription = "Realize the logical components in hardware.";
184
- attribute :>> entryCriteria = "The logical components exist.";
185
- attribute :>> exitCriteria = "The hardware assemblies are declared.";
483
+ ref :>> role = systemArchitect;
484
+ ref :>> guideViewpoint = vpInternalInterconnection;
485
+ attribute :>> outputKinds = ("LogicalPort");
486
+ attribute :>> objectiveDescription = "Give each component the ports it exposes, then connect port to port.";
487
+ attribute :>> entryCriteria = "Components exist.";
488
+ attribute :>> exitCriteria = "Every connection goes port to port.";
489
+ }
490
+
491
+ action stepSysLogicalInteraction : MethodologyWorkflowStep {
492
+ @MemoIdentity { :>> providedId = "STEP-SYS-12"; :>> label = "Describe how they interact"; }
493
+ attribute :>> stage = WorkflowStageKind::logical;
494
+ attribute :>> level = MethodLevelKind::system;
495
+ ref :>> role = systemArchitect;
496
+ ref :>> guideViewpoint = vpSequenceInteraction;
497
+ attribute :>> outputKinds = ("LogicalExchangeItem");
498
+ attribute :>> objectiveDescription = "Show, scenario by scenario, the messages the components send each other.";
499
+ attribute :>> entryCriteria = "Components and their connections exist.";
500
+ attribute :>> exitCriteria = "Each exchange carries a named item.";
501
+ }
502
+
503
+ action stepSysLogicalSegregation : MethodologyWorkflowStep {
504
+ @MemoIdentity { :>> providedId = "STEP-SYS-13"; :>> label = "Mark segregation for risk control"; }
505
+ attribute :>> stage = WorkflowStageKind::logical;
506
+ attribute :>> level = MethodLevelKind::system;
507
+ ref :>> role = systemArchitect;
508
+ ref :>> guideViewpoint = vpLogicalArchitecture;
509
+ attribute :>> outputKinds = ("IsolationBoundary");
510
+ attribute :>> objectiveDescription = "Where a risk control relies on separation, draw the boundary that keeps the parts apart.";
511
+ attribute :>> entryCriteria = "Only if Safety and risk needs it.";
512
+ attribute :>> exitCriteria = "Each segregation a control relies on is drawn.";
186
513
  }
187
514
 
188
515
  action stepSysSoftware : MethodologyWorkflowStep {
189
- @MemoIdentity { :>> providedId = "STEP-SYS-05"; :>> label = "SystemSoftware"; }
190
- attribute :>> stage = WorkflowStageKind::physical;
516
+ @MemoIdentity { :>> providedId = "STEP-SYS-14"; :>> label = "Realize the components in software"; }
517
+ attribute :>> stage = WorkflowStageKind::implementation;
191
518
  attribute :>> level = MethodLevelKind::system;
192
519
  ref :>> role = softwareArchitect;
193
520
  ref :>> guideViewpoint = vpSoftwareComponents;
194
521
  attribute :>> outputKinds = ("SoftwareSystem");
195
- attribute :>> objectiveDescription = "Realize the logical components in software.";
196
- attribute :>> entryCriteria = "The logical components exist.";
522
+ attribute :>> objectiveDescription = "Declare the software and the components it is made of.";
523
+ attribute :>> entryCriteria = "Nothing: start here if the software exists.";
197
524
  attribute :>> exitCriteria = "The software is declared.";
198
525
  }
199
526
 
200
- action stepSysHumanFactors : MethodologyWorkflowStep {
201
- @MemoIdentity { :>> providedId = "STEP-SYS-06"; :>> label = "SystemHumanFactors"; }
202
- attribute :>> stage = WorkflowStageKind::humanFactors;
527
+ action stepSysHardware : MethodologyWorkflowStep {
528
+ @MemoIdentity { :>> providedId = "STEP-SYS-15"; :>> label = "Realize the components in hardware"; }
529
+ attribute :>> stage = WorkflowStageKind::implementation;
530
+ attribute :>> level = MethodLevelKind::system;
531
+ ref :>> role = hardwareEngineer;
532
+ ref :>> guideViewpoint = vpHardwareArchitecture;
533
+ attribute :>> outputKinds = ("PhysicalAssembly");
534
+ attribute :>> objectiveDescription = "Declare the hardware assemblies, from the catalog where they are supplied.";
535
+ attribute :>> entryCriteria = "Nothing: start here if the hardware exists.";
536
+ attribute :>> exitCriteria = "The hardware assemblies are declared.";
537
+ }
538
+
539
+ action stepSysUserInterface : MethodologyWorkflowStep {
540
+ @MemoIdentity { :>> providedId = "STEP-SYS-16"; :>> label = "Lay out the user interface"; }
541
+ attribute :>> stage = WorkflowStageKind::implementation;
203
542
  attribute :>> level = MethodLevelKind::system;
204
543
  ref :>> role = usabilityEngineer;
205
- ref :>> guideViewpoint = vpHumanFactors;
544
+ ref :>> guideViewpoint = vpUILayout;
206
545
  attribute :>> outputKinds = ("UserInterface");
207
- attribute :>> objectiveDescription = "Design how people use the system.";
208
- attribute :>> entryCriteria = "The system use cases exist.";
546
+ attribute :>> objectiveDescription = "Declare the user interface and lay out its screens.";
547
+ attribute :>> entryCriteria = "Nothing: start here if the screens exist.";
209
548
  attribute :>> exitCriteria = "The user interface is declared.";
210
549
  }
211
550
 
551
+ action stepSysDeployment : MethodologyWorkflowStep {
552
+ @MemoIdentity { :>> providedId = "STEP-SYS-17"; :>> label = "Deploy the software onto its hardware"; }
553
+ attribute :>> stage = WorkflowStageKind::realization;
554
+ attribute :>> level = MethodLevelKind::system;
555
+ ref :>> role = softwareArchitect;
556
+ ref :>> guideViewpoint = vpNetworkDeployment;
557
+ attribute :>> outputKinds = ("SoftwareDeploymentUnit");
558
+ attribute :>> objectiveDescription = "Say which software runs on which processing node.";
559
+ attribute :>> entryCriteria = "Software and hardware help.";
560
+ attribute :>> exitCriteria = "Each deployment unit is placed.";
561
+ }
562
+
563
+ action stepSysAssembly : MethodologyWorkflowStep {
564
+ @MemoIdentity { :>> providedId = "STEP-SYS-18"; :>> label = "Place the processing nodes"; }
565
+ attribute :>> stage = WorkflowStageKind::realization;
566
+ attribute :>> level = MethodLevelKind::system;
567
+ ref :>> role = hardwareEngineer;
568
+ ref :>> guideViewpoint = vpPhysicalArchitecture;
569
+ attribute :>> outputKinds = ("ProcessingNode");
570
+ attribute :>> objectiveDescription = "Declare the processing nodes the device is assembled from and how they are connected.";
571
+ attribute :>> entryCriteria = "Hardware helps.";
572
+ attribute :>> exitCriteria = "Each processing node is declared.";
573
+ }
574
+
575
+ // ── One system: the assurance disciplines ────────────────────────────────
576
+
577
+ action stepSysNeeds : MethodologyWorkflowStep {
578
+ @MemoIdentity { :>> providedId = "STEP-SYS-19"; :>> label = "State the user needs"; }
579
+ attribute :>> stage = WorkflowStageKind::requirements;
580
+ attribute :>> level = MethodLevelKind::system;
581
+ ref :>> role = systemArchitect;
582
+ ref :>> guideViewpoint = vpRequirementsTraceability;
583
+ attribute :>> outputKinds = ("Need");
584
+ attribute :>> objectiveDescription = "State what the users need, each naming who needs it. Imported needs keep their source.";
585
+ attribute :>> entryCriteria = "Nothing: start here, or import.";
586
+ attribute :>> exitCriteria = "Each need names its user.";
587
+ }
588
+ #DoneWhen dependency from stepSysNeeds to memo_rules_closure::UserNeedIdentifiesUserRule;
589
+
590
+ action stepSysRequirements : MethodologyWorkflowStep {
591
+ @MemoIdentity { :>> providedId = "STEP-SYS-20"; :>> label = "Write the requirements"; }
592
+ attribute :>> stage = WorkflowStageKind::requirements;
593
+ attribute :>> level = MethodLevelKind::system;
594
+ ref :>> role = systemArchitect;
595
+ ref :>> guideViewpoint = vpRequirementsTraceability;
596
+ attribute :>> outputKinds = ("Requirement");
597
+ attribute :>> objectiveDescription = "Write what the device must do, each derived from a need and satisfied by the design.";
598
+ attribute :>> entryCriteria = "Nothing: start here, or import.";
599
+ attribute :>> exitCriteria = "The requirements are written.";
600
+ }
601
+
212
602
  action stepSysRisk : MethodologyWorkflowStep {
213
- @MemoIdentity { :>> providedId = "STEP-SYS-07"; :>> label = "SystemRisk"; }
603
+ @MemoIdentity { :>> providedId = "STEP-SYS-21"; :>> label = "Identify the hazards"; }
214
604
  attribute :>> stage = WorkflowStageKind::risk;
215
605
  attribute :>> level = MethodLevelKind::system;
216
606
  ref :>> role = safetyEngineer;
217
607
  ref :>> guideViewpoint = vpRiskChain;
218
- attribute :>> outputKinds = ("Hazard", "Risk");
219
- attribute :>> objectiveDescription = "Identify hazards, estimate risk and state the controls.";
220
- attribute :>> entryCriteria = "The system functions exist.";
608
+ attribute :>> inputKinds = ("OperativeScenario");
609
+ attribute :>> outputKinds = ("Hazard");
610
+ attribute :>> objectiveDescription = "Imported or found here, each hazard needs the scenario it arises in. Walk a scenario task by task and ask what could hurt the patient, the operator or a bystander.";
611
+ attribute :>> entryCriteria = "Nothing: start here, or import a hazard list.";
612
+ attribute :>> exitCriteria = "Each hazard has its scenario.";
613
+ }
614
+
615
+ action stepSysHarm : MethodologyWorkflowStep {
616
+ @MemoIdentity { :>> providedId = "STEP-SYS-22"; :>> label = "Describe how harm happens"; }
617
+ attribute :>> stage = WorkflowStageKind::risk;
618
+ attribute :>> level = MethodLevelKind::system;
619
+ ref :>> role = safetyEngineer;
620
+ ref :>> guideViewpoint = vpRiskChain;
621
+ attribute :>> outputKinds = ("HazardousSituation", "Harm");
622
+ attribute :>> objectiveDescription = "For each hazard, the hazardous situation it leads to and the harm that can follow.";
623
+ attribute :>> entryCriteria = "Hazards exist.";
624
+ attribute :>> exitCriteria = "Each hazard has its hazardous situation.";
625
+ }
626
+ #DoneWhen dependency from stepSysHarm to memo_rules_closure::HazardHasSituationRule;
627
+
628
+ action stepSysRiskEstimate : MethodologyWorkflowStep {
629
+ @MemoIdentity { :>> providedId = "STEP-SYS-23"; :>> label = "Estimate the risk"; }
630
+ attribute :>> stage = WorkflowStageKind::risk;
631
+ attribute :>> level = MethodLevelKind::system;
632
+ ref :>> role = safetyEngineer;
633
+ ref :>> guideViewpoint = vpRiskChain;
634
+ attribute :>> outputKinds = ("Risk");
635
+ attribute :>> objectiveDescription = "Estimate the probability and severity of each harm against the risk matrix.";
636
+ attribute :>> entryCriteria = "Hazardous situations exist.";
637
+ attribute :>> exitCriteria = "Each risk is estimated.";
638
+ }
639
+ #DoneWhen dependency from stepSysRiskEstimate to memo_rules_closure::RiskEstimateRule;
640
+
641
+ action stepSysRiskControls : MethodologyWorkflowStep {
642
+ @MemoIdentity { :>> providedId = "STEP-SYS-24"; :>> label = "Decide the controls"; }
643
+ attribute :>> stage = WorkflowStageKind::risk;
644
+ attribute :>> level = MethodLevelKind::system;
645
+ ref :>> role = safetyEngineer;
646
+ ref :>> guideViewpoint = vpRiskChain;
647
+ attribute :>> outputKinds = ("RiskControlMeasure");
648
+ attribute :>> objectiveDescription = "Decide how each hazard is controlled: by design, by protection, or by information. A control is placed in the design by the team that owns it.";
649
+ attribute :>> entryCriteria = "Hazards exist.";
221
650
  attribute :>> exitCriteria = "Each hazard has a control.";
222
651
  }
223
- #LinkedWhen dependency from stepSysRisk to memo_rules_closure::HazardMitigationRule;
652
+ #LinkedWhen dependency from stepSysRiskControls to memo_rules_closure::HazardMitigationRule;
653
+
654
+ action stepSysResidualRisk : MethodologyWorkflowStep {
655
+ @MemoIdentity { :>> providedId = "STEP-SYS-25"; :>> label = "Evaluate residual risk"; }
656
+ attribute :>> stage = WorkflowStageKind::risk;
657
+ attribute :>> level = MethodLevelKind::system;
658
+ ref :>> role = safetyEngineer;
659
+ ref :>> guideViewpoint = vpRiskChain;
660
+ attribute :>> outputKinds = ("ResidualRisk");
661
+ attribute :>> objectiveDescription = "Estimate what is left after the controls, and judge whether it is acceptable.";
662
+ attribute :>> entryCriteria = "Controls exist.";
663
+ attribute :>> exitCriteria = "Each residual risk is evaluated.";
664
+ }
665
+ #DoneWhen dependency from stepSysResidualRisk to memo_rules_closure::ResidualRiskEvaluatedRule;
666
+
667
+ action stepSysAssets : MethodologyWorkflowStep {
668
+ @MemoIdentity { :>> providedId = "STEP-SYS-26"; :>> label = "Identify what can be attacked"; }
669
+ attribute :>> stage = WorkflowStageKind::security;
670
+ attribute :>> level = MethodLevelKind::system;
671
+ ref :>> role = securityEngineer;
672
+ ref :>> guideViewpoint = vpCybersecurity;
673
+ attribute :>> outputKinds = ("CybersecurityAsset");
674
+ attribute :>> objectiveDescription = "Name the assets worth protecting: data, functions and the interfaces that expose them.";
675
+ attribute :>> entryCriteria = "Nothing: start here.";
676
+ attribute :>> exitCriteria = "Each asset is named.";
677
+ }
224
678
 
225
679
  action stepSysSecurity : MethodologyWorkflowStep {
226
- @MemoIdentity { :>> providedId = "STEP-SYS-08"; :>> label = "SystemSecurity"; }
680
+ @MemoIdentity { :>> providedId = "STEP-SYS-27"; :>> label = "Identify the threats"; }
227
681
  attribute :>> stage = WorkflowStageKind::security;
228
682
  attribute :>> level = MethodLevelKind::system;
229
683
  ref :>> role = securityEngineer;
230
684
  ref :>> guideViewpoint = vpCybersecurity;
231
685
  attribute :>> outputKinds = ("Threat");
232
- attribute :>> objectiveDescription = "Identify threats and state the mitigations.";
233
- attribute :>> entryCriteria = "The system functions exist.";
686
+ attribute :>> objectiveDescription = "For each asset, the threats to it.";
687
+ attribute :>> entryCriteria = "Assets help.";
688
+ attribute :>> exitCriteria = "Each asset has its threats.";
689
+ }
690
+ #DoneWhen dependency from stepSysSecurity to memo_rules_closure::AssetThreatLinkRule;
691
+
692
+ action stepSysThreatMitigation : MethodologyWorkflowStep {
693
+ @MemoIdentity { :>> providedId = "STEP-SYS-28"; :>> label = "Mitigate the threats"; }
694
+ attribute :>> stage = WorkflowStageKind::security;
695
+ attribute :>> level = MethodLevelKind::system;
696
+ ref :>> role = securityEngineer;
697
+ ref :>> guideViewpoint = vpCybersecurity;
698
+ attribute :>> outputKinds = ("CyberMitigation");
699
+ attribute :>> objectiveDescription = "State how each threat is mitigated, and where in the design the mitigation lives.";
700
+ attribute :>> entryCriteria = "Threats exist.";
234
701
  attribute :>> exitCriteria = "Each threat is mitigated.";
235
702
  }
236
- #LinkedWhen dependency from stepSysSecurity to memo_rules_closure::ThreatMitigationRule;
703
+ #LinkedWhen dependency from stepSysThreatMitigation to memo_rules_closure::ThreatMitigationRule;
704
+
705
+ action stepSysUseEnvironment : MethodologyWorkflowStep {
706
+ @MemoIdentity { :>> providedId = "STEP-SYS-29"; :>> label = "Describe the use environment"; }
707
+ attribute :>> stage = WorkflowStageKind::humanFactors;
708
+ attribute :>> level = MethodLevelKind::system;
709
+ ref :>> role = usabilityEngineer;
710
+ ref :>> guideViewpoint = vpHumanFactors;
711
+ attribute :>> outputKinds = ("UseEnvironment");
712
+ attribute :>> objectiveDescription = "Describe the conditions people use the device in: light, noise, interruptions, what they wear.";
713
+ attribute :>> entryCriteria = "Nothing: start here.";
714
+ attribute :>> exitCriteria = "Each use environment is described.";
715
+ }
716
+
717
+ action stepSysHumanFactors : MethodologyWorkflowStep {
718
+ @MemoIdentity { :>> providedId = "STEP-SYS-30"; :>> label = "Identify the use errors"; }
719
+ attribute :>> stage = WorkflowStageKind::humanFactors;
720
+ attribute :>> level = MethodLevelKind::system;
721
+ ref :>> role = usabilityEngineer;
722
+ ref :>> guideViewpoint = vpHumanFactors;
723
+ attribute :>> outputKinds = ("UseError");
724
+ attribute :>> objectiveDescription = "Walk the operational tasks for the use errors people could make, starting with the known use problems.";
725
+ attribute :>> entryCriteria = "Workflows and scenarios help.";
726
+ attribute :>> exitCriteria = "Each known use problem is a use error.";
727
+ }
237
728
 
238
729
  action stepSysVerification : MethodologyWorkflowStep {
239
- @MemoIdentity { :>> providedId = "STEP-SYS-09"; :>> label = "SystemVerification"; }
730
+ @MemoIdentity { :>> providedId = "STEP-SYS-31"; :>> label = "Write the verification cases"; }
240
731
  attribute :>> stage = WorkflowStageKind::verificationStage;
241
732
  attribute :>> level = MethodLevelKind::system;
242
733
  ref :>> role = verificationEngineer;
243
734
  ref :>> guideViewpoint = vpVerificationCoverage;
244
735
  attribute :>> outputKinds = ("VerificationCase");
245
- attribute :>> objectiveDescription = "Verify what the system must do and the controls it relies on.";
246
- attribute :>> entryCriteria = "Risks and their controls exist.";
736
+ attribute :>> objectiveDescription = "Write how each requirement and control is verified, and by which method.";
737
+ attribute :>> entryCriteria = "Nothing: start here, or import.";
738
+ attribute :>> exitCriteria = "Each case states its method.";
739
+ }
740
+ #DoneWhen dependency from stepSysVerification to memo_rules_closure::VerificationCaseMethodRule;
741
+
742
+ action stepSysVerificationTargets : MethodologyWorkflowStep {
743
+ @MemoIdentity { :>> providedId = "STEP-SYS-32"; :>> label = "Give each case what it verifies"; }
744
+ attribute :>> stage = WorkflowStageKind::verificationStage;
745
+ attribute :>> level = MethodLevelKind::system;
746
+ ref :>> role = verificationEngineer;
747
+ ref :>> guideViewpoint = vpVerificationCoverage;
748
+ attribute :>> objectiveDescription = "Link each case to the requirements, functions, interfaces and controls it verifies.";
749
+ attribute :>> entryCriteria = "Cases exist; what they verify may come later.";
247
750
  attribute :>> exitCriteria = "Each verification case has a target.";
248
751
  }
249
- #LinkedWhen dependency from stepSysVerification to memo_rules_closure::VerificationCaseTargetRule;
752
+ #LinkedWhen dependency from stepSysVerificationTargets to memo_rules_closure::VerificationCaseTargetRule;
753
+
754
+ action stepSysControlVerification : MethodologyWorkflowStep {
755
+ @MemoIdentity { :>> providedId = "STEP-SYS-33"; :>> label = "Verify the risk controls"; }
756
+ attribute :>> stage = WorkflowStageKind::verificationStage;
757
+ attribute :>> level = MethodLevelKind::system;
758
+ ref :>> role = verificationEngineer;
759
+ ref :>> guideViewpoint = vpVerificationCoverage;
760
+ attribute :>> objectiveDescription = "Every risk control is verified for its implementation and its effectiveness.";
761
+ attribute :>> entryCriteria = "Controls exist.";
762
+ attribute :>> exitCriteria = "Each risk control is verified.";
763
+ }
764
+ #LinkedWhen dependency from stepSysControlVerification to memo_rules_closure::RiskControlVerificationRule;
765
+
766
+ action stepSysValidation : MethodologyWorkflowStep {
767
+ @MemoIdentity { :>> providedId = "STEP-SYS-34"; :>> label = "Validate the use"; }
768
+ attribute :>> stage = WorkflowStageKind::verificationStage;
769
+ attribute :>> level = MethodLevelKind::system;
770
+ ref :>> role = verificationEngineer;
771
+ ref :>> guideViewpoint = vpValidationCoverage;
772
+ attribute :>> outputKinds = ("ValidationCase");
773
+ attribute :>> objectiveDescription = "Show that the device meets the users' needs in its intended use.";
774
+ attribute :>> entryCriteria = "Needs and use cases help.";
775
+ attribute :>> exitCriteria = "Each user need is validated.";
776
+ }
250
777
 
251
778
  action stepSysRelease : MethodologyWorkflowStep {
252
- @MemoIdentity { :>> providedId = "STEP-SYS-10"; :>> label = "SystemRelease"; }
779
+ @MemoIdentity { :>> providedId = "STEP-SYS-35"; :>> label = "Record a release"; }
253
780
  attribute :>> stage = WorkflowStageKind::release;
254
781
  attribute :>> level = MethodLevelKind::system;
255
782
  ref :>> role = regulatoryEngineer;
@@ -260,19 +787,47 @@ package memo_methodology_profiles {
260
787
  }
261
788
 
262
789
  // Recommended order, within a level: which step feeds which. It never holds a step back.
263
- first stepSosContext then stepSosOperational;
790
+ first stepSosContext then stepSosUsers;
791
+ first stepSosUsers then stepSosUseCases;
792
+ first stepSosUseCases then stepSosOperational;
264
793
  first stepSosOperational then stepSosFunctions;
265
794
  first stepSosFunctions then stepSosArchitecture;
266
795
  first stepSosArchitecture then stepSosHazards;
267
796
 
268
- first stepSysOperational then stepSysFunctional;
797
+ first stepSysUsers then stepSysUseContext;
798
+ first stepSysUseContext then stepSysOperational;
799
+ first stepSysOperational then stepSysWorkflows;
800
+ first stepSysWorkflows then stepSysScenarios;
801
+ first stepSysScenarios then stepSysFunctional;
802
+ first stepSysFunctional then stepSysFunctionalExchanges;
803
+ first stepSysFunctionalExchanges then stepSysFunctionalChains;
269
804
  first stepSysFunctional then stepSysLogical;
270
- first stepSysLogical then stepSysHardware;
805
+ first stepSysLogical then stepSysComponentFunctions;
806
+ first stepSysComponentFunctions then stepSysLogicalAllocation;
807
+ first stepSysLogicalAllocation then stepSysLogicalInterfaces;
808
+ first stepSysLogicalInterfaces then stepSysLogicalInteraction;
809
+ first stepSysLogicalInteraction then stepSysLogicalSegregation;
271
810
  first stepSysLogical then stepSysSoftware;
272
- first stepSysOperational then stepSysHumanFactors;
273
- first stepSysFunctional then stepSysRisk;
274
- first stepSysFunctional then stepSysSecurity;
275
- first stepSysRisk then stepSysVerification;
811
+ first stepSysLogical then stepSysHardware;
812
+ first stepSysSoftware then stepSysUserInterface;
813
+ first stepSysSoftware then stepSysDeployment;
814
+ first stepSysHardware then stepSysAssembly;
815
+ first stepSysOperational then stepSysNeeds;
816
+ first stepSysNeeds then stepSysRequirements;
817
+ first stepSysScenarios then stepSysRisk;
818
+ first stepSysRisk then stepSysHarm;
819
+ first stepSysHarm then stepSysRiskEstimate;
820
+ first stepSysRiskEstimate then stepSysRiskControls;
821
+ first stepSysRiskControls then stepSysResidualRisk;
822
+ first stepSysFunctional then stepSysAssets;
823
+ first stepSysAssets then stepSysSecurity;
824
+ first stepSysSecurity then stepSysThreatMitigation;
825
+ first stepSysUseContext then stepSysUseEnvironment;
826
+ first stepSysUseEnvironment then stepSysHumanFactors;
827
+ first stepSysRequirements then stepSysVerification;
828
+ first stepSysVerification then stepSysVerificationTargets;
829
+ first stepSysRiskControls then stepSysControlVerification;
830
+ first stepSysNeeds then stepSysValidation;
276
831
  first stepSysVerification then stepSysRelease;
277
832
 
278
833
  part gateLightComplete : QualityGate {