memo_assurance_safety_risk_analysis¶

SysML API


Public namespace	`memo::assurance::safety_risk::analysis`
Declared package	`memo_assurance_safety_risk_analysis`
Source	`src/assurance/safety_risk/analysis/memo_fmea.sysml`

Namespace hierarchy¶

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

Packages¶

Package
`memo_assurance_safety_risk_analysis`

Imports¶

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

Declarations¶

Name	SysML kind	Description	Specializes
`FMEAWorksheet`	`part def`	Fmeaworksheet definition specializing `AnalysisArtifact`.	`AnalysisArtifact`
`FailureMode`	`item def`	Failure mode definition specializing `RiskItem`.	`RiskItem`
`FailureEffect`	`item def`	Failure effect definition specializing `RiskItem`.	`RiskItem`
`FailureCause`	`item def`	Failure cause definition specializing `RiskItem`.	`RiskItem`
`DetectionMethod`	`part def`	Detection method definition specializing `MemoPart`.	`MemoPart`
`FMEAAction`	`part def`	Fmeaaction definition specializing `VerifiableElement`.	`VerifiableElement`
`FaultTree`	`part def`	Fault tree definition specializing `AnalysisArtifact`.	`AnalysisArtifact`
`FaultTreeNode`	`part def`	Fault tree node definition specializing `MemoPart`.	`MemoPart`
`MinimalCutSet`	`item def`	Minimal cut set definition specializing `RiskItem`.	`RiskItem`
`HAZOPStudy`	`part def`	Hazopstudy definition specializing `AnalysisArtifact`.	`AnalysisArtifact`
`HAZOPNode`	`part def`	Hazopnode definition specializing `MemoPart`.	`MemoPart`
`HAZOPDeviation`	`item def`	Hazopdeviation definition specializing `RiskItem`.	`RiskItem`
`CauseKind`	`enum def`	Controlled values for cause: `failureCausesEffect`, `failureCausedBy`, `contributesToHazard`, `leadsToHazard`, `originatesFrom`, `useErrorLeadsToHazard`.	—
`Causes`	`connection def`	Typed relationship for causes.	`MemoRelationship`
`DetectedBy`	`connection def`	Typed relationship for detected by.	`MemoRelationship`
`InputToGate`	`connection def`	Typed relationship for input to gate.	`MemoRelationship`
`ProducesEvent`	`connection def`	Typed relationship for produces event.	`MemoRelationship`
`ContainsEvent`	`connection def`	Typed relationship for contains event.	`MemoRelationship`
`IdentifiesHazard`	`connection def`	Typed relationship for identifies hazard.	`MemoRelationship`
`HasFailureMode`	`connection def`	Typed relationship for has failure mode.	`MemoRelationship`

FMEAWorksheet¶

part def FMEAWorksheet specializes AnalysisArtifact

Property	Value
Description	Fmeaworksheet definition specializing `AnalysisArtifact`.
Kind	`part def`
Abstract	No
Specializes	`AnalysisArtifact`
Owning package	`memo_assurance_safety_risk_analysis`

FailureMode¶

item def FailureMode specializes RiskItem

Property	Value
Description	Failure mode definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk_analysis`

FailureEffect¶

item def FailureEffect specializes RiskItem

Property	Value
Description	Failure effect definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk_analysis`

FailureCause¶

item def FailureCause specializes RiskItem

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

DetectionMethod¶

part def DetectionMethod specializes MemoPart

Property	Value
Description	Detection method definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_assurance_safety_risk_analysis`

FMEAAction¶

part def FMEAAction specializes VerifiableElement

Property	Value
Description	Fmeaaction definition specializing `VerifiableElement`.
Kind	`part def`
Abstract	No
Specializes	`VerifiableElement`
Owning package	`memo_assurance_safety_risk_analysis`

FaultTree¶

part def FaultTree specializes AnalysisArtifact

Property	Value
Description	Fault tree definition specializing `AnalysisArtifact`.
Kind	`part def`
Abstract	No
Specializes	`AnalysisArtifact`
Owning package	`memo_assurance_safety_risk_analysis`

FaultTreeNode¶

part def FaultTreeNode specializes MemoPart

Property	Value
Description	Fault tree node definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_assurance_safety_risk_analysis`

MinimalCutSet¶

item def MinimalCutSet specializes RiskItem

Property	Value
Description	Minimal cut set definition specializing `RiskItem`.
Kind	`item def`
Abstract	No
Specializes	`RiskItem`
Owning package	`memo_assurance_safety_risk_analysis`

HAZOPStudy¶

part def HAZOPStudy specializes AnalysisArtifact

Property	Value
Description	Hazopstudy definition specializing `AnalysisArtifact`.
Kind	`part def`
Abstract	No
Specializes	`AnalysisArtifact`
Owning package	`memo_assurance_safety_risk_analysis`

HAZOPNode¶

part def HAZOPNode specializes MemoPart

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

HAZOPDeviation¶

item def HAZOPDeviation specializes RiskItem

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

CauseKind¶

enum def CauseKind

Property	Value
Description	Controlled values for cause: `failureCausesEffect`, `failureCausedBy`, `contributesToHazard`, `leadsToHazard`, `originatesFrom`, `useErrorLeadsToHazard`.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_assurance_safety_risk_analysis`

Causes¶

connection def Causes :> MemoRelationship

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

DetectedBy¶

connection def DetectedBy :> MemoRelationship

Property	Value
Description	Typed relationship for detected by.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk_analysis`

InputToGate¶

connection def InputToGate :> MemoRelationship

Property	Value
Description	Typed relationship for input to gate.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk_analysis`

ProducesEvent¶

connection def ProducesEvent :> MemoRelationship

Property	Value
Description	Typed relationship for produces event.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk_analysis`

ContainsEvent¶

connection def ContainsEvent :> MemoRelationship

Property	Value
Description	Typed relationship for contains event.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk_analysis`

IdentifiesHazard¶

connection def IdentifiesHazard :> MemoRelationship

Property	Value
Description	Typed relationship for identifies hazard.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk_analysis`

HasFailureMode¶

connection def HasFailureMode :> MemoRelationship

Property	Value
Description	Typed relationship for has failure mode.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_assurance_safety_risk_analysis`

Source¶

assurance/safety_risk/analysis/memo_fmea.sysml

package memo_assurance_safety_risk_analysis {
    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_safety_risk::*;   // RiskItem
    part def FMEAWorksheet specializes AnalysisArtifact {
        attribute analysisScope : String;
        attribute standardReference : String;
        attribute analysisBasis : String;
        attribute revisionDate : String;
        attribute reviewer : String;
    }
    // An FMEA worksheet row states, on one line, what fails, what that does,
    // how likely it is, and what controls it. The RPN triple carries the
    // *scoring*; `effect` and `probability` carry the two facts a reader of the
    // row needs in words. They are summaries, not replacements: the modelled
    // form of an effect is a FailureEffect linked by Causes, and the modelled
    // form of a control is a RiskControlMeasure linked by
    // Mitigates(mitigationKind = failureMode) — traversable as
    // `traverse: incoming mitigates`. MEMO deliberately does not add a second
    // failure-mode-to-control relation; one whole/part and one mitigation
    // relation is the lean shape the rest of the ontology already uses.
    item def FailureMode specializes RiskItem {
        attribute failureModeKind : FailureModeKind;
        doc /* One-line statement of what this failure does, for the worksheet
             * row. The structured form is a FailureEffect. */
        attribute effect : String[0..1];
        attribute severityRating : Integer;
        doc /* Qualitative likelihood, the ISO 14971 register. `occurrenceRating`
             * is the same fact as an FMEA score; both are kept because an FMEA
             * reports the score and a risk file reports the qualitative band. */
        attribute probability : ProbabilityKind[0..1];
        attribute occurrenceRating : Integer;
        attribute detectionRating : Integer;
        attribute rpn : Integer;
        attribute criticality : CriticalityKind;
    }
    item def FailureEffect specializes RiskItem {
        attribute effectLevel : FailureEffectLevelKind;
        attribute effectOnPatient : String;
        attribute effectOnOperator : String;
        attribute effectOnSystem : String;
        attribute severity : SeverityKind;
    }
    item def FailureCause specializes RiskItem {
        attribute causeCategory : FailureCauseCategoryKind;
        attribute causeDescription : String;
        attribute occurrenceRating : ProbabilityKind;
        attribute preventionMethod : String;
    }
    part def DetectionMethod specializes MemoPart {
        attribute methodKind : DetectionMethodKind;
        attribute detectionPoint : String;
        attribute confidence : DetectionKind;
    }
    part def FMEAAction specializes VerifiableElement {
        attribute actionKind : FMEAActionKind;
        attribute responsible : String;
        attribute targetCompletionDate : String;
        attribute revisedRpn : Integer;
    }
    part def FaultTree specializes AnalysisArtifact {
        attribute standardReference : String;
        attribute analysisScope : String;
        attribute topEventDescription : String;
        attribute cutSetSummary : String;
        attribute revisionDate : String;
    }
    part def FaultTreeNode specializes MemoPart {
        attribute eventKind : FaultTreeEventKind;
        attribute probability : Real;
        attribute failureRate : Real;
        attribute exposureTime : Real;
        attribute :>> description : String;
        attribute gateKind : FaultTreeGateKind;
        attribute kValue : Integer;
        attribute nValue : Integer;
    }
    item def MinimalCutSet specializes RiskItem {
        attribute cutSetOrder : Integer;
        attribute probability : Real;
        attribute involvedEvents : String;
        attribute significance : String;
    }
    part def HAZOPStudy specializes AnalysisArtifact {
        attribute standardReference : String;
        attribute processDescription : String;
        attribute studyScope : String;
        attribute teamComposition : String;
    }
    part def HAZOPNode specializes MemoPart {
        attribute nodeDescription : String;
        attribute designIntent : String;
        attribute operatingConditions : String;
    }
    item def HAZOPDeviation specializes RiskItem {
        attribute guideWord : HAZOPGuideWordKind;
        attribute parameter : String;
        attribute cause : String;
        attribute consequence : String;
        attribute existingSafeguard : String;
        attribute severity : SeverityKind;
        attribute likelihood : ProbabilityKind;
        attribute recommendation : 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.
    // Causes unifies the former causal edges of the ISO 14971 / FMEA / FTA
    // chains — CausesEffect, CausedBy, ContributesToHazard, LeadsToHazard,
    // OriginatesFrom, UseErrorLeadsToHazard — keyed by causeKind. cause is the
    // originating element, effect the consequence.
    enum def CauseKind {
        enum failureCausesEffect;
        enum failureCausedBy;
        enum contributesToHazard;
        enum leadsToHazard;
        enum originatesFrom;
        enum useErrorLeadsToHazard;
    }
    connection def Causes :> MemoRelationship {
        attribute causeKind : CauseKind;
        end cause : MemoPart :>> source;
        end effect : RiskItem :>> target;
    }
    abstract connection causesLinks : Causes[*];
    metadata def <causes> CausesMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = causesLinks meta SysML::Usage;
    }
    connection def DetectedBy :> MemoRelationship {
        end failureMode : FailureMode :>> source;
        end detectionMethod : DetectionMethod :>> target;
    }
    abstract connection detectedByLinks : DetectedBy[*];
    metadata def <detectedBy> DetectedByMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = detectedByLinks meta SysML::Usage;
    }
    connection def InputToGate :> MemoRelationship {
        end input : FaultTreeNode :>> source;
        end gate : FaultTreeNode :>> target;
    }
    abstract connection inputToGateLinks : InputToGate[*];
    metadata def <inputToGate> InputToGateMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = inputToGateLinks meta SysML::Usage;
    }
    connection def ProducesEvent :> MemoRelationship {
        end gate : FaultTreeNode :>> source;
        end eventElement : FaultTreeNode :>> target;
    }
    abstract connection producesEventLinks : ProducesEvent[*];
    metadata def <producesEvent> ProducesEventMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = producesEventLinks meta SysML::Usage;
    }
    connection def ContainsEvent :> MemoRelationship {
        end cutSet : MinimalCutSet :>> source;
        end eventElement : FaultTreeNode :>> target;
    }
    abstract connection containsEventLinks : ContainsEvent[*];
    metadata def <containsEvent> ContainsEventMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = containsEventLinks meta SysML::Usage;
    }
    connection def IdentifiesHazard :> MemoRelationship {
        end deviation : HAZOPDeviation :>> source;
        end hazard : Hazard :>> target;
    }
    abstract connection identifiesHazardLinks : IdentifiesHazard[*];
    metadata def <identifiesHazard> IdentifiesHazardMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = identifiesHazardLinks meta SysML::Usage;
    }
    connection def HasFailureMode :> MemoRelationship {
        end element : MemoPart :>> source;
        end failureMode : FailureMode :>> target;
    }
    abstract connection hasFailureModeLinks : HasFailureMode[*];
    metadata def <hasFailureMode> HasFailureModeMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = hasFailureModeLinks meta SysML::Usage;
    }
}