memo_assurance_safety_risk¶

SysML API


Public namespace	`memo::assurance::safety_risk`
Declared package	`memo_assurance_safety_risk`
Source	`src/assurance/safety_risk/memo_risk.sysml`

Namespace hierarchy¶

memo → memo::assurance → memo::assurance::safety_risk

Packages¶

Package
`memo_assurance_safety_risk`

Imports¶

Visibility	Target
private	`Metaobjects::SemanticMetadata`
private	`ScalarValues::*`
private	`memo_core_relationships::*`
private	`memo_core_common::*`
private	`memo_core_enumerations::*`
private	`memo_assurance_requirements::*`

Declarations¶

Name	SysML kind	Description	Specializes
`Risk`	`part def`	Risk definition specializing `RiskDriver`.	`RiskDriver`
`ResidualRisk`	`part def`	Residual risk definition specializing `Risk`.	`Risk`
`RiskMatrix`	`part def`	Risk matrix definition specializing `MemoPart`.	`MemoPart`
`DesignControlRiskRow`	`part def`	Design control risk row definition specializing `Risk`.	`Risk`
`SafetyRelatedCharacteristic`	`part def`	A device characteristic whose implementation, failure, or misuse can affect safety. This is the modelable output of ISO 14971 §5.3.	`MemoPart`
`RiskItem`	`item def`	Risk item definition specializing `MemoItem`.	`MemoItem`
`Hazard`	`item def`	Hazard definition specializing `RiskItem`.	`RiskItem`
`SequenceOfEvents`	`item def`	Sequence of events definition specializing `RiskItem`.	`RiskItem`
`HazardCause`	`item def`	Hazard cause definition specializing `RiskItem`.	`RiskItem`
`HazardousSituation`	`item def`	Hazardous situation definition specializing `RiskItem`.	`RiskItem`
`Harm`	`item def`	Harm definition specializing `RiskItem`.	`RiskItem`
`RiskControlMeasure`	`part def`	Risk control measure definition specializing `VerifiableElement`.	`VerifiableElement`
`Benefit`	`part def`	Benefit definition specializing `MemoPart`.	`MemoPart`
`OverallResidualRiskEvaluation`	`part def`	Overall residual risk evaluation definition specializing `MemoPart`.	`MemoPart`
`TracesRisk`	`connection def`	Moved out of memo_core_relationships: their ends are typed against types declared here, and core must not depend on a domain package. ISO 14971 risk chain — distinct sequence-of-events relations over risk elements.	`MemoRelationship`
`AssessedAgainst`	`connection def`	Typed relationship for assessed against.	`MemoRelationship`
`MitigationKind`	`enum def`	Controlled values for mitigation: `hazard`, `vulnerability`, `failureMode`, `cutSet`, `fmeaAction`.	—
`Mitigates`	`connection def`	Typed relationship for mitigates.	`MemoRelationship`

Risk¶

part def Risk specializes RiskDriver

Property	Value
Description	Risk definition specializing `RiskDriver`.
Kind	`part def`
Abstract	No
Specializes	`RiskDriver`
Owning package	`memo_assurance_safety_risk`

ResidualRisk¶

part def ResidualRisk specializes Risk

Property	Value
Description	Residual risk definition specializing `Risk`.
Kind	`part def`
Abstract	No
Specializes	`Risk`
Owning package	`memo_assurance_safety_risk`

RiskMatrix¶

part def RiskMatrix specializes MemoPart

Property	Value
Description	Risk matrix definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_assurance_safety_risk`

DesignControlRiskRow¶

part def DesignControlRiskRow specializes Risk

Property	Value
Description	Design control risk row definition specializing `Risk`.
Kind	`part def`
Abstract	No
Specializes	`Risk`
Owning package	`memo_assurance_safety_risk`

SafetyRelatedCharacteristic¶

part def SafetyRelatedCharacteristic specializes MemoPart

Property	Value
Description	A device characteristic whose implementation, failure, or misuse can affect safety. This is the modelable output of ISO 14971 §5.3.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_assurance_safety_risk`

RiskItem¶

abstract item def RiskItem specializes MemoItem

Property	Value
Description	Risk item definition specializing `MemoItem`.
Kind	`item def`
Abstract	Yes
Specializes	`MemoItem`
Owning package	`memo_assurance_safety_risk`

Hazard¶

item def Hazard specializes RiskItem

Property	Value
Description	Hazard definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk`

SequenceOfEvents¶

item def SequenceOfEvents specializes RiskItem

Property	Value
Description	Sequence of events definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk`

HazardCause¶

item def HazardCause specializes RiskItem

Property	Value
Description	Hazard cause definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk`

HazardousSituation¶

item def HazardousSituation specializes RiskItem

Property	Value
Description	Hazardous situation definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk`

Harm¶

item def Harm specializes RiskItem

Property	Value
Description	Harm definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk`

RiskControlMeasure¶

part def RiskControlMeasure specializes VerifiableElement

Property	Value
Description	Risk control measure definition specializing `VerifiableElement`.
Kind	`part def`
Abstract	No
Specializes	`VerifiableElement`
Owning package	`memo_assurance_safety_risk`

Benefit¶

part def Benefit specializes MemoPart

Property	Value
Description	Benefit definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_assurance_safety_risk`

OverallResidualRiskEvaluation¶

part def OverallResidualRiskEvaluation specializes MemoPart

Property	Value
Description	Overall residual risk evaluation definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_assurance_safety_risk`

TracesRisk¶

connection def TracesRisk :> MemoRelationship

Property	Value
Description	Moved out of memo_core_relationships: their ends are typed against types declared here, and core must not depend on a domain package. ISO 14971 risk chain — distinct sequence-of-events relations over risk elements.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk`

AssessedAgainst¶

connection def AssessedAgainst :> MemoRelationship

Property	Value
Description	Typed relationship for assessed against.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk`

MitigationKind¶

enum def MitigationKind

Property	Value
Description	Controlled values for mitigation: `hazard`, `vulnerability`, `failureMode`, `cutSet`, `fmeaAction`.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_assurance_safety_risk`

Mitigates¶

connection def Mitigates :> MemoRelationship

Property	Value
Description	Typed relationship for mitigates.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk`

Source¶

assurance/safety_risk/memo_risk.sysml

package memo_assurance_safety_risk {
    private import Metaobjects::SemanticMetadata;
    private import ScalarValues::*;
    private import memo_core_relationships::*;   // MemoRelationship

    private import memo_core_common::*;
    private import memo_core_enumerations::*;
    private import memo_assurance_requirements::*;
    part def Risk specializes RiskDriver {
        attribute probabilityEstimate : ProbabilityKind;
        attribute severityEstimate : SeverityKind;
        attribute riskLevel : CriticalityKind;
        attribute acceptability : RiskAcceptabilityKind;
        attribute estimationBasis : String;
        attribute analysisContext : String;
        attribute foreseeableMisuseIncluded : Boolean;
    }
    part def ResidualRisk specializes Risk {
        attribute benefitRiskRequired : Boolean;
    }
    part def RiskMatrix specializes MemoPart {
        attribute probabilityScaleDefinition : String;
        attribute severityScaleDefinition : String;
        attribute riskLevelMapping : String;
        attribute acceptabilityThresholds : String;
    }
    part def DesignControlRiskRow specializes Risk {
        attribute rowTitle : String;
        attribute hazardAnalysis : String;
        attribute hazardCategory : String;
        attribute hazardSubcategory : String;
        attribute causeSequenceOfEventsFailure : String;
        attribute harmText : String;
        attribute probabilityBeforeRaw : String;
        attribute severityBeforeRaw : String;
        attribute riskBeforeMeasureRaw : String;
        attribute probabilityAfterRaw : String;
        attribute severityAfterRaw : String;
        attribute riskAfterMitigationRaw : String;
        attribute cannotReduceFurther : Boolean;
        attribute linkSummary : String;
    }
    // A device characteristic whose implementation, failure, or misuse can
    // affect safety. This is the modelable output of ISO 14971 §5.3.
    part def SafetyRelatedCharacteristic specializes MemoPart {
        attribute characteristic : String;
        attribute safetyImpact : String;
        attribute normalUseRelevant : Boolean;
        attribute faultConditionRelevant : Boolean;
    }
    // ─── Risk-element base ──────────────────────────────────────────
    // The common supertype of the item-based elements an ISO 14971 / FMEA /
    // FTA chain relates: hazards, sequences of events, hazardous situations,
    // harms, causes, failure modes, fault-tree events, cut sets, HAZOP
    // deviations, vulnerabilities.
    //
    // It exists so the risk relations can TYPE their ends. Before it, every
    // one of them (Causes, TracesRisk, DetectedBy, InputToGate, ProducesEvent,
    // ContainsEvent, IdentifiesHazard, Mitigates, ImpactsSafety) fell back to
    // MemoPart — which every element in MEMO is — so the authoring picker
    // offered fault-tree edges when linking a screen to a requirement.
    //
    // It is deliberately an `item def` and deliberately does NOT cover Risk /
    // ResidualRisk / RiskMatrix, which are parts: a risk is an assessed
    // judgement about a chain, not a link in it, and it is reached by
    // AssessedAgainst instead. One base per metaclass is the right shape here
    // — forcing the two families under one supertype would put a hazard and a
    // risk matrix back in the same picker.
    abstract item def RiskItem specializes MemoItem;

    item def Hazard specializes RiskItem {
        attribute hazardType : HazardTypeKind;
        attribute severity : SeverityKind;
        attribute foreseeable : Boolean;
    }
    item def SequenceOfEvents specializes RiskItem {
        attribute initiatingEvent : String;
        attribute contributingFactors : String;
    }
    // A categorized root cause in a hazard causal tree (FDA GIIP
    // taxonomy pattern: cause -> hazard -> hazardous situation -> harm;
    // several HazardCause elements may converge on one Hazard).
    item def HazardCause specializes RiskItem {
        attribute causeSource : CauseSourceKind;
        attribute contributingFactors : String;
    }
    item def HazardousSituation specializes RiskItem {
        attribute exposedPersons : String;
        attribute operatingCondition : String;
    }
    item def Harm specializes RiskItem {
        attribute clinicalImpact : String;
        attribute reversibility : String;
        attribute severity : SeverityKind;
    }
    part def RiskControlMeasure specializes VerifiableElement {
        attribute controlKind : RiskControlKind;
        attribute implementationKind : RiskControlImplementationKind;
        attribute verificationStatus : String;
    }
    part def Benefit specializes MemoPart {
        attribute beneficialOutcome : String;
        attribute beneficiary : String;
        attribute clinicalSignificance : String;
        attribute supportingEvidence : String;
    }
    part def OverallResidualRiskEvaluation specializes MemoPart {
        attribute conclusion : String;
        attribute reviewer : String;
    }

    // ── Relations owned by this package ─────────────────────────────
    // Moved out of memo_core_relationships: their ends are typed against
    // types declared here, and core must not depend on a domain package.
    // ISO 14971 risk chain — distinct sequence-of-events relations over risk elements.
    connection def TracesRisk :> MemoRelationship {
        end sourceRiskElement : RiskItem :>> source;
        end targetRiskElement : RiskItem :>> target;
    }
    abstract connection tracesRiskLinks : TracesRisk[*];
    metadata def <tracesRisk> TracesRiskMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = tracesRiskLinks meta SysML::Usage;
    }
    connection def AssessedAgainst :> MemoRelationship {
        end risk : Risk :>> source;
        end riskMatrix : RiskMatrix :>> target;
    }
    abstract connection assessedAgainstLinks : AssessedAgainst[*];
    metadata def <assessedAgainst> AssessedAgainstMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = assessedAgainstLinks meta SysML::Usage;
    }
    // Mitigates unifies the control/action → risk-element edges of the
    // ISO 14971 / FMEA / FTA / cyber chains — MitigatesHazard,
    // MitigatesVulnerability, MitigatedByControl, BrokenByControl,
    // AddressedByAction — keyed by mitigationKind. control is the mitigating
    // control/action; mitigatedElement is the hazard/vulnerability/failure/cut set.
    enum def MitigationKind {
        enum hazard;
        enum vulnerability;
        enum failureMode;
        enum cutSet;
        enum fmeaAction;
    }
    connection def Mitigates :> MemoRelationship {
        attribute mitigationKind : MitigationKind;
        // Untyped: controls/hazards may be item defs (RiskControlMeasure, Hazard, …).
        end control :>> source;
        end mitigatedElement : RiskItem :>> target;
    }
    abstract connection mitigatesLinks : Mitigates[*];
    metadata def <mitigates> MitigatesMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = mitigatesLinks meta SysML::Usage;
    }
}