memo_architecture_logical_structure¶

SysML API


Public namespace	`memo::architecture::logical::structure`
Declared package	`memo_architecture_logical_structure`
Source	`src/architecture/logical/structure/memo_logical_structure.sysml`

Namespace hierarchy¶

memo → memo::architecture → memo::architecture::logical → memo::architecture::logical::structure

Packages¶

Package
`memo_architecture_logical_structure`

Imports¶

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

Declarations¶

Name	SysML kind	Description	Specializes
`FlowContentKind`	`enum def`	What a logical connection carries: information and control, but also energy, material, fluid, and mechanical force (§10).	—
`ChannelRoleKind`	`enum def`	Controlled values for channel role: `primary`, `secondary`, `redundant`, `diverse`, `monitor`, `watchdog`, `interlock`, `independentProtection`.	—
`ComponentRoleKind`	`enum def`	Controlled values for component role: `channel`, `dataStore`, `controlElement`, `userInterface`, `externalSystem`, `generic`.	—
`SystemTypeKind`	`enum def`	The discipline a logical block is realized in. Orthogonal to `componentRole`: a subsystem may be software, a system may be hardware, and a block whose realization is not yet decided stays `logical`. This does NOT relocate the element.…	—
`SystemOfSystems`	`part def`	Three types rather than three role values, because they differ in what they may CONTAIN — and containment legality cannot live on an attribute. The allowed children are declared as typed part features, which is how SysML v2 already states "what may be contained".…	`LogicalComponent`
`System`	`part def`	System definition specializing `LogicalComponent`.	`LogicalComponent`
`Subsystem`	`part def`	Subsystem definition specializing `LogicalComponent`.	`LogicalComponent`
`LogicalComponent`	`part def`	Logical component definition specializing `MemoPart`.	`MemoPart`
`LogicalPort`	`port def`	Boundary features and contracts.	`MemoPort`
`LogicalInterface`	`interface def`	Logical interface definition specializing `MemoInterface`.	`MemoInterface`
`LogicalExchangeItem`	`item def`	Logical exchange item definition specializing `MemoItem`.	`MemoItem`
`LogicalConnector`	`connection def`	A typed logical connection between two components' ports.	`MemoRelationship`
`LogicalExchange`	`part def`	A transfer of a typed item across a connector.	`MemoPart`
`LogicalBehavior`	`part def`	States and modes of the logical solution (kept distinct from UI state and from physical device configuration).	`MemoPart`
`IsolationBoundary`	`part def`	Isolation, fault containment, and trust boundaries (§10).	`MemoPart`
`FaultContainmentRegion`	`part def`	Fault containment region definition specializing `MemoPart`.	`MemoPart`
`IndependentOf`	`connection def`	Claimed independence between channels (common-cause defense).	`MemoRelationship`

FlowContentKind¶

enum def FlowContentKind

Property	Value
Description	What a logical connection carries: information and control, but also energy, material, fluid, and mechanical force (§10).
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_logical_structure`

ChannelRoleKind¶

enum def ChannelRoleKind

Property	Value
Description	Controlled values for channel role: `primary`, `secondary`, `redundant`, `diverse`, `monitor`, `watchdog`, `interlock`, `independentProtection`.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_logical_structure`

ComponentRoleKind¶

enum def ComponentRoleKind

Property	Value
Description	Controlled values for component role: `channel`, `dataStore`, `controlElement`, `userInterface`, `externalSystem`, `generic`.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_logical_structure`

SystemTypeKind¶

enum def SystemTypeKind

Property	Value
Description	The discipline a logical block is realized in. Orthogonal to `componentRole`: a subsystem may be software, a system may be hardware, and a block whose realization is not yet decided stays `logical`. This does NOT relocate the element.…
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_logical_structure`

SystemOfSystems¶

part def SystemOfSystems specializes LogicalComponent

Property	Value
Description	Three types rather than three role values, because they differ in what they may CONTAIN — and containment legality cannot live on an attribute. The allowed children are declared as typed part features, which is how SysML v2 already states "what may be contained".…
Kind	`part def`
Abstract	No
Specializes	`LogicalComponent`
Owning package	`memo_architecture_logical_structure`

System¶

part def System specializes LogicalComponent

Property	Value
Description	System definition specializing `LogicalComponent`.
Kind	`part def`
Abstract	No
Specializes	`LogicalComponent`
Owning package	`memo_architecture_logical_structure`

Subsystem¶

part def Subsystem specializes LogicalComponent

Property	Value
Description	Subsystem definition specializing `LogicalComponent`.
Kind	`part def`
Abstract	No
Specializes	`LogicalComponent`
Owning package	`memo_architecture_logical_structure`

LogicalComponent¶

part def LogicalComponent specializes MemoPart

Property	Value
Description	Logical component definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_logical_structure`

LogicalPort¶

port def LogicalPort specializes MemoPort

Property	Value
Description	Boundary features and contracts.
Kind	`port def`
Abstract	No
Specializes	`MemoPort`
Owning package	`memo_architecture_logical_structure`

LogicalInterface¶

interface def LogicalInterface specializes MemoInterface

Property	Value
Description	Logical interface definition specializing `MemoInterface`.
Kind	`interface def`
Abstract	No
Specializes	`MemoInterface`
Owning package	`memo_architecture_logical_structure`

LogicalExchangeItem¶

item def LogicalExchangeItem specializes MemoItem

Property	Value
Description	Logical exchange item definition specializing `MemoItem`.
Kind	`item def`
Abstract	No
Specializes	`MemoItem`
Owning package	`memo_architecture_logical_structure`

LogicalConnector¶

connection def LogicalConnector :> MemoRelationship

Property	Value
Description	A typed logical connection between two components' ports.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_architecture_logical_structure`

LogicalExchange¶

part def LogicalExchange specializes MemoPart

Property	Value
Description	A transfer of a typed item across a connector.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_logical_structure`

LogicalBehavior¶

part def LogicalBehavior specializes MemoPart

Property	Value
Description	States and modes of the logical solution (kept distinct from UI state and from physical device configuration).
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_logical_structure`

IsolationBoundary¶

part def IsolationBoundary specializes MemoPart

Property	Value
Description	Isolation, fault containment, and trust boundaries (§10).
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_logical_structure`

FaultContainmentRegion¶

part def FaultContainmentRegion specializes MemoPart

Property	Value
Description	Fault containment region definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_logical_structure`

IndependentOf¶

connection def IndependentOf :> MemoRelationship

Property	Value
Description	Claimed independence between channels (common-cause defense).
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_architecture_logical_structure`

Source¶

architecture/logical/structure/memo_logical_structure.sysml

// Logical architecture (§10). Technology-independent structure: what parts of
// the solution exist and how they interact, before committing to software,
// electronics, or mechanics. Redundancy is expressed by typed channel roles
// plus independence constraints — never by duplicating identically named
// components.
package memo_architecture_logical_structure {
    private import Metaobjects::SemanticMetadata;
    private import ScalarValues::*;

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

    // What a logical connection carries: information and control, but also
    // energy, material, fluid, and mechanical force (§10).
    enum def FlowContentKind {
        enum information;
        enum command;
        enum status;
        enum measurement;
        enum alarm;
        enum configuration;
        enum energy;
        enum material;
        enum fluid;
        enum mechanicalForce;
    }

    enum def ChannelRoleKind {
        enum primary;
        enum secondary;
        enum redundant;
        enum diverse;
        enum monitor;
        enum watchdog;
        enum interlock;
        enum independentProtection;
    }

    // The role a logical component plays. Was a subclass branch
    // (LogicalChannel / LogicalDataStore / LogicalControlElement /
    // LogicalUserInterface / LogicalExternalSystem); now one attribute, because
    // those all share the same relationships and differed only by a couple of
    // descriptive attributes.
    //
    // System / Subsystem / SystemOfSystems are types below, not values here:
    // each admits a different set of children, and a value on an attribute
    // cannot carry containment legality.
    enum def ComponentRoleKind {
        enum channel;
        enum dataStore;
        enum controlElement;
        enum userInterface;
        enum externalSystem;
        enum generic;
    }

    // The discipline a logical block is realized in. Orthogonal to
    // `componentRole`: a subsystem may be software, a system may be hardware,
    // and a block whose realization is not yet decided stays `logical`.
    //
    // This does NOT relocate the element. The block remains logical-layer —
    // MEMO encodes layer by owning package, and this one is
    // memo_architecture_logical_structure. `systemType` records what the block
    // WILL BE realized in, which is a logical-architecture decision made
    // before any software or hardware element exists. Once those elements do
    // exist, AllocatedTo carries the actual allocation and this attribute
    // stays as the stated intent.
    enum def SystemTypeKind {
        enum logical;
        enum software;
        enum hardware;
    }

    // ─── System hierarchy ────────────────────────────────────────
    // Three types rather than three role values, because they differ in what
    // they may CONTAIN — and containment legality cannot live on an attribute.
    //
    // The allowed children are declared as typed part features, which is how
    // SysML v2 already states "what may be contained". No new relationship is
    // introduced: `Composes` remains the single containment relation for
    // instances, exactly as everywhere else in MEMO. The features below say
    // which types are admissible; Composes records the actual links.

    part def SystemOfSystems specializes LogicalComponent {
        // Constituent systems are independently operated and independently
        // managed, collaborating for a capability none delivers alone
        // (ISO/IEC/IEEE 21841). A connected pump talking to a hospital
        // infusion-management server is one; a pump and its own pole-mounted
        // battery are not — which is why ownership is recorded here and is the
        // attribute that distinguishes an SoS from a merely large system.
        attribute systemBoundaryDescription : String;
        attribute constituentOwnership : String;
        // A constituent may itself coordinate systems-of-systems, or it may be
        // an independently operated system. Subsystems and components remain
        // inside one of those constituent systems.
        part constituentSystemOfSystems : SystemOfSystems[0..*];
        part constituentSystem : System[0..*];
    }

    part def System specializes LogicalComponent {
        attribute systemBoundaryDescription : String;
        part system : System[0..*];
        part subsystem : Subsystem[0..*];
        part component : LogicalComponent[0..*];
    }

    part def Subsystem specializes LogicalComponent {
        attribute systemBoundaryDescription : String;
        part subsystem : Subsystem[0..*];
        part component : LogicalComponent[0..*];
    }

    // One logical component. `componentRole` selects what it is, `systemType`
    // what it is realized in; the role-specific attributes below are all
    // optional so a component carries only the ones its role needs. A channel
    // claiming independence must still be linked by IndependentOf with its
    // basis stated.
    part def LogicalComponent specializes MemoPart {
        attribute componentRole : ComponentRoleKind;
        attribute systemType : SystemTypeKind[0..1];
        attribute responsibility : String;
        attribute decompositionLevel : String;
        attribute safetyPartition : String;
        // channel (safety role + diversity)
        attribute channelRole : ChannelRoleKind[0..1];
        attribute diversityBasis : String;
        // data store
        attribute persistenceRequirement : String;
        attribute integrityRequirement : String;
        // control element
        attribute controlLaw : String;
        attribute controlledVariable : String;
        // user interface
        attribute interactionSummary : String;
        // external system
        attribute externalOwner : String;
    }

    // Boundary features and contracts.
    port def LogicalPort specializes MemoPort;
    interface def LogicalInterface specializes MemoInterface {
        attribute contentKind : FlowContentKind;
        attribute interactionPattern : String;
        end providerPort : LogicalPort;
        end consumerPort : ~LogicalPort;
    }
    item def LogicalExchangeItem specializes MemoItem {
        attribute contentKind : FlowContentKind;
    }

    // A typed logical connection between two components' ports.
    connection def LogicalConnector :> MemoRelationship {
        attribute contentKind : FlowContentKind;
        attribute direction : DirectionKind;
        end sourceComponent : LogicalComponent :>> source;
        end targetComponent : LogicalComponent :>> target;
    }
    abstract connection logicalConnectorLinks : LogicalConnector[*];
    metadata def <logicalConnector> LogicalConnectorMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = logicalConnectorLinks meta SysML::Usage;
    }
    // A transfer of a typed item across a connector.
    part def LogicalExchange specializes MemoPart {
        attribute contentKind : FlowContentKind;
        attribute direction : DirectionKind;
        attribute latencyRequirement : String;
        ref exchangedItem : LogicalExchangeItem[0..1];
        ref sourcePort : LogicalPort[0..1];
        ref targetPort : LogicalPort[0..1];
    }

    // States and modes of the logical solution (kept distinct from UI state
    // and from physical device configuration).

    part def LogicalBehavior specializes MemoPart {
        attribute behaviorSummary : String;
        attribute executionSemantics : String;
    }

    // Isolation, fault containment, and trust boundaries (§10).
    part def IsolationBoundary specializes MemoPart {
        attribute boundaryKind : String;
        attribute isolationMechanism : String;
    }
    part def FaultContainmentRegion specializes MemoPart {
        attribute containmentRationale : String;
    }

    // Claimed independence between channels (common-cause defense).
    connection def IndependentOf :> MemoRelationship {
        attribute independenceBasis : String;
        end channel : LogicalComponent :>> source;
        end otherChannel : LogicalComponent :>> target;
    }
    abstract connection independentOfLinks : IndependentOf[*];
    metadata def <independentOf> IndependentOfMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = independentOfLinks meta SysML::Usage;
    }
    // `MonitorsChannel` is native `dependency` (R10-S6): write
    // `dependency <monitorChannel> to <monitoredComponent>;` instead.

}