memo_architecture_operational_scenarios

SysML API

Public namespace	memo::architecture::operational::scenarios
Declared package	memo_architecture_operational_scenarios
Source	src/architecture/operational/scenarios/memo_scenarios.sysml

Namespace hierarchy

memo → memo::architecture → memo::architecture::operational → memo::architecture::operational::scenarios

Packages

Package
memo_architecture_operational_scenarios

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_context_use_context::*
private	memo_architecture_operational_activities::*
private	memo_architecture_operational_workflows::*
private	memo_architecture_operational_use_cases::*

Declarations

Name	SysML kind	Description	Specializes
ScenarioKind	enum def	A scenario is a nominal path or an alternate (exception/recovery) path. Defaults to nominal.	—
OperativeScenario	action def	Operative scenario definition specializing MemoAction.	MemoAction
HasScenario	connection def	A workflow is composed of one or more scenarios (nominal + alternate paths). ScenarioOccurrence/Executes were removed: an actual execution is a native SysML usage of the scenario, not a separate def + relation.	MemoRelationship

ScenarioKind

enum def ScenarioKind

Property	Value
Description	A scenario is a nominal path or an alternate (exception/recovery) path. Defaults to nominal.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_architecture_operational_scenarios

OperativeScenario

action def OperativeScenario specializes MemoAction

Property	Value
Description	Operative scenario definition specializing MemoAction.
Kind	action def
Abstract	No
Specializes	MemoAction
Owning package	memo_architecture_operational_scenarios

HasScenario

connection def HasScenario :> MemoRelationship

Property	Value
Description	A workflow is composed of one or more scenarios (nominal + alternate paths). ScenarioOccurrence/Executes were removed: an actual execution is a native SysML usage of the scenario, not a separate def + relation.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_architecture_operational_scenarios

Source

architecture/operational/scenarios/memo_scenarios.sysml

// Scenario foundation. A scenario is a selected path through a
// workflow (or functional flow), classified by its kind plus three independent
// dimensions — variant, operational condition, and purpose. An occurrence is an actual or hypothetical execution
// of a scenario. Alternate scenarios reference their base scenario and
// variation point instead of duplicating the workflow.
package memo_architecture_operational_scenarios {
    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_context_use_context::*;
    private import memo_architecture_operational_activities::*;
    private import memo_architecture_operational_workflows::*;
    private import memo_architecture_operational_use_cases::*;

    // A scenario is a nominal path or an alternate (exception/recovery) path.
    // Defaults to nominal.
    enum def ScenarioKind {
        enum nominal;
        enum alternate;
    }

    action def OperativeScenario specializes MemoAction {
        attribute scenarioKind : ScenarioKind default ScenarioKind::nominal;
        attribute initialState : String;
        attribute trigger : String;
        attribute preCondition : String;
        attribute expectedResult : String;
        attribute postCondition : String;
        attribute pathSummary : String;

        // The workflow this scenario belongs to is expressed by the workflow
        // (HasScenario); a nominal/alternate pair are scenarios of the same
        // workflow, distinguished by scenarioKind — no baseScenario back-ref.
        // Actors are derived from `perform` on the nested steps, not listed.
        ref useContext : UseContext[0..1];
        // threat scenario
        attribute actorDescription : String;
        attribute assumptionSummary : String;
        attribute guaranteeSummary : String;
        attribute securityObjective : String;
        attribute abuseCaseReference : String;
        attribute defaultCategory : ThreatCategoryKind[0..1];
        // verification scenario
        attribute verificationEnvironment : String;
        attribute stimulusSummary : String;
        // hazard-related use scenario (IEC 62366-1 3.9)
        attribute hazardReference : String;
        attribute selectionRationale : String;
    }

    // A workflow is composed of one or more scenarios (nominal + alternate
    // paths). ScenarioOccurrence/Executes were removed: an actual execution is
    // a native SysML *usage* of the scenario, not a separate def + relation.
    connection def HasScenario :> MemoRelationship {
        end owningWorkflow : OperationalWorkflow :>> source;
        end pathScenario : OperativeScenario :>> target;
    }
    abstract connection hasScenarioLinks : HasScenario[*];
    metadata def <hasScenario> HasScenarioMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = hasScenarioLinks meta SysML::Usage;
    }
}