@memoarchitect/ontology 0.22.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.
- package/README.md +1 -1
- package/examples/gastric-bypass-variants/model/catalog/gastric_bypass_variants.sysml +17 -17
- package/examples/gpca-pump/model/catalog/gpca_operational.sysml +6 -12
- package/examples/reusable-instrument/model/catalog/reusable_instrument.sysml +2 -2
- package/examples/robot-cell-family/model/catalog/sos/chains.sysml +1 -1
- package/examples/robot-cell-family/model/catalog/sos/use_cases.sysml +1 -1
- package/examples/robot-cell-family/model/catalog/systems/manipulation/manipulation_system.sysml +1 -1
- package/examples/robot-cell-family/model/catalog/systems/navigation/navigation_system.sysml +1 -1
- package/examples/robot-cell-family/model/catalog/systems/perception/perception_system.sysml +1 -1
- package/examples/surgical-closure-workflow/model/catalog/surgical_closure_workflow.sysml +2 -2
- package/examples/sysml-diagram-samples/model/catalog/samples/browser_view.sysml +3 -3
- package/examples/sysml-diagram-samples/model/catalog/samples/use_case_view.sysml +5 -5
- package/examples/temperature-alarm/model/catalog/temperature_alarm.sysml +1 -1
- package/extensions/aadl/memo.package.yaml +1 -1
- package/extensions/anatomy/memo.package.yaml +1 -1
- package/extensions/clinical/memo.package.yaml +1 -1
- package/extensions/cloud/memo.package.yaml +1 -1
- package/extensions/container/memo.package.yaml +1 -1
- package/extensions/messaging/memo.package.yaml +1 -1
- package/extensions/ros/memo.package.yaml +1 -1
- package/methodologies/default/memo.package.yaml +1 -1
- package/methodologies/gpca/memo.package.yaml +1 -1
- package/ontology/memo.package.yaml +1 -1
- package/package.json +1 -1
- package/profile/memo.package.yaml +1 -1
- package/src/architecture/functional/functions/memo_functions.sysml +6 -1
- package/src/architecture/operational/rollups/memo_rollups.sysml +3 -3
- package/src/architecture/operational/use_cases/memo_use_cases.sysml +4 -4
- package/src/architecture/operational/workflows/memo_workflows.sysml +15 -16
- package/src/artifacts/templates/dhf/21cfr820/user-needs.md +1 -1
- package/src/artifacts/templates/dhf/iec-62366/summative-eval.md +1 -1
- package/src/artifacts/templates/dhf/iec-62366/ue-plan.md +1 -1
- package/src/artifacts/templates/dhf/iec-62366/urra.md +1 -1
- package/src/artifacts/templates/dhf/iec-62366/use-spec.md +1 -1
- package/src/assurance/requirements/needs/memo_needs.sysml +1 -1
- package/src/core/enumerations/memo_enumerations.sysml +10 -0
- package/src/core/relationships/memo_workspace_membership.sysml +4 -1
- package/src/methodology/profiles/memo_profiles.sysml +628 -73
- package/src/methodology/workflow/memo_workflow.sysml +57 -7
- package/src/rules/ontology/ontology_invariants.sysml +56 -12
- package/src/viewpoints/catalog/memo_viewpoint_catalog.sysml +28 -28
- package/src/viewpoints/clinical_workflow/clinical_workflow_viewpoint.sysml +1 -1
- package/src/viewpoints/context/context_viewpoint.sysml +1 -1
- package/src/viewpoints/cybersecurity/cybersecurity_viewpoint.sysml +1 -1
- package/src/viewpoints/definitions/memo_view_layout.sysml +19 -0
- package/src/viewpoints/functional/functional_viewpoint.sysml +1 -1
- package/src/viewpoints/logical/logical_viewpoint.sysml +1 -1
- package/src/viewpoints/operational/operational_viewpoint.sysml +1 -1
- package/src/viewpoints/physical/physical_viewpoint.sysml +1 -1
- package/src/viewpoints/requirements/requirements_viewpoint.sysml +1 -1
- package/src/viewpoints/risk/risk_viewpoint.sysml +1 -1
- package/src/viewpoints/software/software_viewpoint.sysml +1 -1
- package/src/viewpoints/usability/usability_viewpoint.sysml +1 -1
- package/src/viewpoints/verification/verification_viewpoint.sysml +1 -1
- package/stage1/opensysml-ad5ae1d762e9e7107282daa2.json.gz +0 -0
- package/stage1/syside-ff96456991e9f3c2ca352a54.ids.gz +0 -0
- package/stage1/syside-ff96456991e9f3c2ca352a54.json.gz +0 -0
- package/stage1/opensysml-38b58af8f1ce330053e05f1e.json.gz +0 -0
- package/stage1/syside-ca5c563522d5f99a57a61152.ids.gz +0 -0
- package/stage1/syside-ca5c563522d5f99a57a61152.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.
|
|
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.
|
|
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
|
|
74
|
-
// systems and at each system.
|
|
75
|
-
//
|
|
76
|
-
// say when it is
|
|
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 = "
|
|
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
|
|
91
|
-
@MemoIdentity { :>> providedId = "STEP-SOS-02"; :>> label = "
|
|
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"
|
|
97
|
-
attribute :>> objectiveDescription = "
|
|
98
|
-
attribute :>> entryCriteria = "
|
|
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-
|
|
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 = "
|
|
110
|
-
attribute :>> entryCriteria = "Clinical procedures and workflows
|
|
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-
|
|
116
|
-
attribute :>> stage = WorkflowStageKind::
|
|
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 = "
|
|
122
|
-
attribute :>> entryCriteria = "
|
|
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-
|
|
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
|
|
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-
|
|
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
|
|
147
|
-
attribute :>> entryCriteria = "
|
|
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-
|
|
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 = "
|
|
159
|
-
attribute :>> entryCriteria = "
|
|
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-
|
|
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
|
|
171
|
-
attribute :>> entryCriteria = "
|
|
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
|
|
477
|
+
#LinkedWhen dependency from stepSysLogicalAllocation to memo_rules_closure::LogicalFunctionAllocationRule;
|
|
175
478
|
|
|
176
|
-
action
|
|
177
|
-
@MemoIdentity { :>> providedId = "STEP-SYS-
|
|
178
|
-
attribute :>> stage = WorkflowStageKind::
|
|
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 =
|
|
181
|
-
ref :>> guideViewpoint =
|
|
182
|
-
attribute :>> outputKinds = ("
|
|
183
|
-
attribute :>> objectiveDescription = "
|
|
184
|
-
attribute :>> entryCriteria = "
|
|
185
|
-
attribute :>> exitCriteria = "
|
|
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-
|
|
190
|
-
attribute :>> stage = WorkflowStageKind::
|
|
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 = "
|
|
196
|
-
attribute :>> entryCriteria = "
|
|
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
|
|
201
|
-
@MemoIdentity { :>> providedId = "STEP-SYS-
|
|
202
|
-
attribute :>> stage = WorkflowStageKind::
|
|
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 =
|
|
544
|
+
ref :>> guideViewpoint = vpUILayout;
|
|
206
545
|
attribute :>> outputKinds = ("UserInterface");
|
|
207
|
-
attribute :>> objectiveDescription = "
|
|
208
|
-
attribute :>> entryCriteria = "
|
|
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-
|
|
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 :>>
|
|
219
|
-
attribute :>>
|
|
220
|
-
attribute :>>
|
|
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
|
|
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-
|
|
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 = "
|
|
233
|
-
attribute :>> entryCriteria = "
|
|
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
|
|
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-
|
|
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 = "
|
|
246
|
-
attribute :>> entryCriteria = "
|
|
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
|
|
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-
|
|
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
|
|
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
|
|
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
|
|
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
|
|
273
|
-
first
|
|
274
|
-
first
|
|
275
|
-
first
|
|
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 {
|