memo_architecture_operational_workflows¶

SysML API


Public namespace	`memo::architecture::operational::workflows`
Declared package	`memo_architecture_operational_workflows`
Source	`src/architecture/operational/workflows/memo_workflows.sysml`

Namespace hierarchy¶

memo → memo::architecture → memo::architecture::operational → memo::architecture::operational::workflows

Packages¶

Package
`memo_architecture_operational_workflows`

Imports¶

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

Declarations¶

Name	SysML kind	Description	Specializes
`WorkflowStateKind`	`enum def`	As-is vs. to-be vs. contingency is a typed dimension of the workflow, not a name suffix.	—
`StepTransformationKind`	`enum def`	Controlled values for step transformation: `preserves`, `automates`, `augments`, `eliminates`.	—
`OperationalWorkflow`	`action def`	Operational workflow definition specializing `MemoAction`.	`MemoAction`
`RealizesUseCase`	`connection def`	The use case a workflow realizes. Many workflows may trace to one use case; the use case does not own its workflows (the trace points upward, workflow → use case).	`MemoRelationship`
`ControlNodeKind`	`enum def`	decision / fork / join / handoff.	—
`WorkflowControlNode`	`action def`	A workflow control node. The role is given by controlKind; the kind-specific fields below are set only for the relevant controlKind. handoff = transfer of responsibility between roles (shift change, room-to-lab).	`MemoAction`
`WorkflowResource`	`part def`	Resources a workflow requires: information, materials, or equipment by reference.	`MemoPart`
`Supports`	`connection def`	Typed relationship for supports.	`MemoRelationship`
`RequiresResource`	`connection def`	Typed relationship for requires resource.	`MemoRelationship`
`TransformKind`	`enum def`	Controlled values for transform: `step`, `workflow`, `replacesWorkflow`.	—
`Transforms`	`connection def`	Typed relationship from `MemoAction` to `MemoAction`.	`MemoRelationship`

WorkflowStateKind¶

enum def WorkflowStateKind

Property	Value
Description	As-is vs. to-be vs. contingency is a typed dimension of the workflow, not a name suffix.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_operational_workflows`

StepTransformationKind¶

enum def StepTransformationKind

Property	Value
Description	Controlled values for step transformation: `preserves`, `automates`, `augments`, `eliminates`.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_operational_workflows`

OperationalWorkflow¶

action def OperationalWorkflow specializes MemoAction

Property	Value
Description	Operational workflow definition specializing `MemoAction`.
Kind	`action def`
Abstract	No
Specializes	`MemoAction`
Owning package	`memo_architecture_operational_workflows`

RealizesUseCase¶

connection def RealizesUseCase :> MemoRelationship

Property	Value
Description	The use case a workflow realizes. Many workflows may trace to one use case; the use case does not own its workflows (the trace points upward, workflow → use case).
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_architecture_operational_workflows`

ControlNodeKind¶

enum def ControlNodeKind

Property	Value
Description	decision / fork / join / handoff.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_operational_workflows`

WorkflowControlNode¶

action def WorkflowControlNode specializes MemoAction

Property	Value
Description	A workflow control node. The role is given by controlKind; the kind-specific fields below are set only for the relevant controlKind. handoff = transfer of responsibility between roles (shift change, room-to-lab).
Kind	`action def`
Abstract	No
Specializes	`MemoAction`
Owning package	`memo_architecture_operational_workflows`

WorkflowResource¶

part def WorkflowResource specializes MemoPart

Property	Value
Description	Resources a workflow requires: information, materials, or equipment by reference.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_operational_workflows`

Supports¶

connection def Supports :> MemoRelationship

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

RequiresResource¶

connection def RequiresResource :> MemoRelationship

Property	Value
Description	Typed relationship for requires resource.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_architecture_operational_workflows`

TransformKind¶

enum def TransformKind

Property	Value
Description	Controlled values for transform: `step`, `workflow`, `replacesWorkflow`.
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_operational_workflows`

Transforms¶

connection def Transforms :> MemoRelationship

Property	Value
Description	Typed relationship from `MemoAction` to `MemoAction`.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_architecture_operational_workflows`

Source¶

architecture/operational/workflows/memo_workflows.sysml

// First-class operational workflows. An OperationalWorkflow is
// a reusable definition of how clinical or service work is performed — it may
// exist before any device is selected. A scenario (memo_architecture_operational_scenarios) is a
// selected path through a workflow; an occurrence is an execution of a
// scenario. Workflows are action defs: steps, decisions, forks/joins, and
// successions use native SysML v2 action semantics where portable.
package memo_architecture_operational_workflows {
    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_context_actors::*;
    private import memo_architecture_operational_activities::*;
    private import memo_architecture_operational_use_cases::*;

    // As-is vs. to-be vs. contingency is a typed dimension of the workflow,
    // not a name suffix.
    enum def WorkflowStateKind {
        enum asIs;
        enum toBe;
        enum contingency;
        enum deprecated;
    }

    enum def StepTransformationKind {
        enum preserves;
        enum automates;
        enum augments;
        enum eliminates;
    }

    action def OperationalWorkflow specializes MemoAction {
        attribute workflowState : WorkflowStateKind;
        attribute entryCondition : String;
        attribute completionCondition : String;
        attribute recoveryPathSummary : String;
        attribute timingConstraints : String;
        attribute environmentSummary : String;
    }

    // The use case a workflow realizes. Many workflows may trace to one use
    // case; the use case does not own its workflows (the trace points upward,
    // workflow → use case).
    connection def RealizesUseCase :> MemoRelationship {
        end realizingWorkflow : OperationalWorkflow :>> source;
        end realizedUseCase : UseCase :>> target;
    }
    abstract connection realizesUseCaseLinks : RealizesUseCase[*];
    metadata def <realizesUseCase> RealizesUseCaseMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = realizesUseCaseLinks meta SysML::Usage;
    }


    // decision / fork / join / handoff.
    enum def ControlNodeKind {
        enum decision;
        enum 'fork';
        enum 'join';
        enum handoff;
    }

    // A workflow control node. The role is given by controlKind; the
    // kind-specific fields below are set only for the relevant controlKind.
    // handoff = transfer of responsibility between roles (shift change, room-to-lab).
    action def WorkflowControlNode specializes MemoAction {
        attribute controlKind : ControlNodeKind;
        attribute decisionQuestion : String[0..1];
        attribute decisionCriteria : String[0..1];
        attribute parallelismRationale : String[0..1];
        attribute joinCondition : String[0..1];
        attribute informationTransferred : String[0..1];
    }

    // Resources a workflow requires: information, materials, or equipment by
    // reference.
    part def WorkflowResource specializes MemoPart {
        attribute resourceKind : String;
        attribute quantity : String;
        ref resolvedProduct : MemoPart[0..1];
    }

    // ── Workflow-level relationships ─────────────────────────────
    // An element supports (affords, enables) an action — e.g. a UI element
    // that affords a user task. Use-case and capability tracing are direct
    // refs now (OperationalWorkflow.useCase,
    // OperativeAction.contributesToCapabilities), so the former
    // SupportKind discriminator is gone: what used to be three enum values
    // that each implied a different target type are now two typed refs plus
    // this one plain relation.
    connection def Supports :> MemoRelationship {
        end supporter :>> source;
        end supported : MemoAction :>> target;
    }
    abstract connection supportsLinks : Supports[*];
    metadata def <supports> SupportsMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = supportsLinks meta SysML::Usage;
    }
    connection def RequiresResource :> MemoRelationship {
        end workflow : OperationalWorkflow :>> source;
        end resource : WorkflowResource :>> target;
    }
    abstract connection requiresResourceLinks : RequiresResource[*];
    metadata def <requiresResource> RequiresResourceMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = requiresResourceLinks meta SysML::Usage;
    }

    // ── Workflow transformation (as-is → to-be) ──────────────────
    // Transforms unifies TransformsStep / TransformsWorkflow / ReplacesWorkflow
    // (tailoring of workflow structure: as-is → to-be), keyed by transformKind.
    enum def TransformKind {
        enum step;
        enum workflow;
        enum replacesWorkflow;
    }
    connection def Transforms :> MemoRelationship {
        attribute transformKind : TransformKind;
        attribute transformation : StepTransformationKind[0..1];
        attribute transformationRationale : String[0..1];
        end source : MemoAction;
        end target : MemoAction;
    }
    abstract connection transformsLinks : Transforms[*];
    metadata def <transforms> TransformsMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = transformsLinks meta SysML::Usage;
    }
    // The device or system whose introduction enables a workflow.
}