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	A scenario is a MemoConstrainedOccurrence: it carries the native precondition and postcondition constraints a function does, redefined with an expression (constraint :>> precondition { level >= 0 }).…	MemoAction

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, MemoConstrainedOccurrence

Property	Value
Description	A scenario is a MemoConstrainedOccurrence: it carries the native precondition and postcondition constraints a function does, redefined with an expression (constraint :>> precondition { level >= 0 }).…
Kind	action def
Abstract	No
Specializes	MemoAction
Owning package	memo_architecture_operational_scenarios

Source

architecture/operational/scenarios/memo_scenarios.sysml

// Scenario foundation. A scenario is a selected path through a workflow,
// classified by its kind (nominal or alternate). It is nested in the workflow
// it is a path through, so a nominal scenario and its alternates are siblings
// there. An actual or hypothetical execution is a native usage of the
// scenario, not a separate element.
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;
    }

    // A scenario is a `MemoConstrainedOccurrence`: it carries the native `precondition` and
    // `postcondition` constraints a function does, redefined with an expression
    // (`constraint :>> precondition { level >= 0 }`). `preCondition` and `postCondition` below are the
    // same two conditions in words, for what no expression says ("patient assessed"); the constraint
    // is for one that can be checked.
    action def OperativeScenario specializes MemoAction, MemoConstrainedOccurrence {
        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 the one it is nested in
        // (a `HasScenario` relation was removed for that reason); 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;
        ref abuseCase : OperativeScenario[0..1];
        attribute defaultCategory : ThreatCategoryKind[0..1];
        // verification scenario
        attribute verificationEnvironment : String;
        attribute stimulusSummary : String;
        // hazard-related use scenario (IEC 62366-1 3.9)
        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.
}