memo_assurance_requirements_needs

SysML API

Public namespace	memo::assurance::requirements::needs
Declared package	memo_assurance_requirements_needs
Source	src/assurance/requirements/needs/memo_needs.sysml

Namespace hierarchy

memo → memo::assurance → memo::assurance::requirements → memo::assurance::requirements::needs

Packages

Package
memo_assurance_requirements_needs

Imports

Visibility	Target
private	ScalarValues::*
private	Metaobjects::SemanticMetadata
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::*

Declarations

Name	SysML kind	Description	Specializes
NeedKind	enum def	Controlled values for need: user, clinicalUser, patientUser, business, service, regulatory, operational, designControl.	—
Need	requirement def	Need definition specializing MemoNeed.	MemoNeed
HeldBy	connection def	Whose need this is. The holder is a modelled participant — a User, with the profile IEC 62366-1 asks for, or another operational participant — so "which users does this need serve" is a question the model answers rather than a sentence a reader interprets.	MemoRelationship

NeedKind

enum def NeedKind

Property	Value
Description	Controlled values for need: user, clinicalUser, patientUser, business, service, regulatory, operational, designControl.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_assurance_requirements_needs

Need

requirement def Need specializes MemoNeed

Property	Value
Description	Need definition specializing MemoNeed.
Kind	requirement def
Abstract	No
Specializes	MemoNeed
Owning package	memo_assurance_requirements_needs

HeldBy

connection def HeldBy :> MemoRelationship

Property	Value
Description	Whose need this is. The holder is a modelled participant — a User, with the profile IEC 62366-1 asks for, or another operational participant — so "which users does this need serve" is a question the model answers rather than a sentence a reader interprets.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_assurance_requirements_needs

Source

assurance/requirements/needs/memo_needs.sysml

// Needs (§4). A Need is a problem-space expectation stated in stakeholder
// language; requirements (memo_assurance_requirements) are the solution-space
// obligations derived from needs. Need specializes the part-based
// RequirementDriver so it can serve as a typed end of trace relations
// (DerivesFrom, Motivates).
package memo_assurance_requirements_needs {
    private import ScalarValues::*;

    private import Metaobjects::SemanticMetadata;

    private import memo_core_common::*;
    private import memo_core_enumerations::*;
    private import memo_core_relationships::*;
    // A need is held by someone and arises in a context, and both are modelled
    // elements. Assurance may depend on architecture; the reverse may not.
    private import memo_architecture_operational_context_actors::*;
    private import memo_architecture_operational_context_use_context::*;

    // The kind of need. Was a subclass branch (StakeholderNeed / UserNeed /
    // ClinicalUserNeed / PatientUserNeed / BusinessNeed / ServiceNeed /
    // RegulatoryNeed / OperationalNeed / DesignControlNeed); now one attribute.
    // The exact terms survive as enum values, so design-input classification
    // (ISO 13485 §7.3.3, IEC 62366-1 user needs) is unchanged — it is simply
    // an attribute of the one Need type rather than a class the modeler picks.
    enum def NeedKind {
        enum 'stakeholder';
        enum user;
        enum clinicalUser;
        enum patientUser;
        enum business;
        enum service;
        enum regulatory;
        enum operational;
        enum designControl;
    }

    requirement def Need specializes MemoNeed {
        attribute needKind : NeedKind;
        // A user need (IEC 62366-1) says WHOSE need it is with HeldBy, and the
        // user's characteristics live on the User: `userPopulation`,
        // `impairmentConsiderations`, `intendedTraining`, `intendedQualification`.
        // A `userPopulationReference` string stood here and held prose — "ward
        // nurses, including those wearing corrective lenses" — which is two
        // typed attributes of a user profile written as one sentence nothing
        // could read, on the wrong element.
        // regulatory need
        attribute jurisdiction : String;
        attribute regulationReference : String;
        // The context an operational need arises in. Typed, because UseContext
        // carries the care setting, environment and jurisdiction that an
        // `operationalContextReference` string could only describe.
        ref useContext : UseContext[0..1];
        // design-control need (ISO 13485 design input)
        attribute sourceFolder : String;
    }

    // Whose need this is. The holder is a modelled participant — a User, with
    // the profile IEC 62366-1 asks for, or another operational participant —
    // so "which users does this need serve" is a question the model answers
    // rather than a sentence a reader interprets.
    connection def HeldBy :> MemoRelationship {
        end need : MemoNeed :>> source;
        end holder : OperationalParticipant :>> target;
    }
    abstract connection heldByLinks : HeldBy[*];
    metadata def <heldBy> HeldByMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = heldByLinks meta SysML::Usage;
    }
}