memo_architecture_operational_structure

SysML API

Public namespace	memo::architecture::operational::structure
Declared package	memo_architecture_operational_structure
Source	src/architecture/operational/structure/memo_operational.sysml

Namespace hierarchy

memo → memo::architecture → memo::architecture::operational → memo::architecture::operational::structure

Packages

Package
memo_architecture_operational_structure

Imports

Visibility	Target
private	Metaobjects::SemanticMetadata
private	ScalarValues::*
private	memo_core_common::*
private	memo_core_enumerations::*
private	memo_core_relationships::*
private	memo_architecture_operational_use_cases::*

Declarations

Name	SysML kind	Description	Specializes
IntendedUse	part def	IEC 62366-1 / ISO 14971 intended use: the medical device's declared purpose and the root of the operational spine. A MemoMission, because "mission" has no medical-device meaning — intended use is what a device exists to do.…	MemoMission
OperationalEntity	part def	Operational entity definition specializing MemoPart.	MemoPart
OperationalCapability	part def	Operational capability definition specializing MemoPart.	MemoPart
RequiresCapability	connection def	The intended use requires these operational capabilities (ARCADIA: Mission Requires Capability).	MemoRelationship
EnablesUseCase	connection def	An operational capability enables a use case (the ability the actor draws on to accomplish the goal). Capability is tied to the use case, not to individual activities.	MemoRelationship

IntendedUse

part def IntendedUse specializes MemoMission

Property	Value
Description	IEC 62366-1 / ISO 14971 intended use: the medical device's declared purpose and the root of the operational spine. A MemoMission, because "mission" has no medical-device meaning — intended use is what a device exists to do.…
Kind	part def
Abstract	No
Specializes	MemoMission
Owning package	memo_architecture_operational_structure

OperationalEntity

part def OperationalEntity specializes MemoPart

Property	Value
Description	Operational entity definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_architecture_operational_structure

OperationalCapability

part def OperationalCapability specializes MemoPart

Property	Value
Description	Operational capability definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_architecture_operational_structure

RequiresCapability

connection def RequiresCapability :> MemoRelationship

Property	Value
Description	The intended use requires these operational capabilities (ARCADIA: Mission Requires Capability).
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_architecture_operational_structure

EnablesUseCase

connection def EnablesUseCase :> MemoRelationship

Property	Value
Description	An operational capability enables a use case (the ability the actor draws on to accomplish the goal). Capability is tied to the use case, not to individual activities.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_architecture_operational_structure

Source

architecture/operational/structure/memo_operational.sysml

package memo_architecture_operational_structure {
    private import Metaobjects::SemanticMetadata;
    private import ScalarValues::*;

    private import memo_core_common::*;
    private import memo_core_enumerations::*;
    private import memo_core_relationships::*;
    private import memo_architecture_operational_use_cases::*;

    // IEC 62366-1 / ISO 14971 intended use: the medical device's declared
    // purpose and the root of the operational spine. A MemoMission, because
    // "mission" has no medical-device meaning — intended use is what a device
    // exists to do. Was in memo_assurance_requirements; moved here as the
    // operational-world root.
    part def IntendedUse specializes MemoMission {
        attribute indication : String;
        attribute contraindication : String;
        attribute patientPopulation : String;
        attribute clinicalBenefit : String;
        attribute regulatoryClassification : String;
    }
    part def OperationalEntity specializes MemoPart {
        attribute entityKind : OperationalEntityKind;
        attribute operationalDomain : String;
        attribute responsibility : String;
    }
    part def OperationalCapability specializes MemoPart {
        attribute capabilityLevel : String;
        attribute preCondition : String;
        attribute postCondition : String;
    }

    // The intended use requires these operational capabilities (ARCADIA:
    // Mission Requires Capability).
    connection def RequiresCapability :> MemoRelationship {
        end requiringIntendedUse : IntendedUse :>> source;
        end requiredCapability : OperationalCapability :>> target;
    }
    abstract connection requiresCapabilityLinks : RequiresCapability[*];
    metadata def <requiresCapability> RequiresCapabilityMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = requiresCapabilityLinks meta SysML::Usage;
    }

    // An operational capability enables a use case (the ability the actor draws
    // on to accomplish the goal). Capability is tied to the use case, not to
    // individual activities.
    connection def EnablesUseCase :> MemoRelationship {
        end enablingCapability : OperationalCapability :>> source;
        end enabledUseCase : UseCase :>> target;
    }
    abstract connection enablesUseCaseLinks : EnablesUseCase[*];
    metadata def <enablesUseCase> EnablesUseCaseMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = enablesUseCaseLinks meta SysML::Usage;
    }

}