Design considerations for initial package release

[capsulecorplab]

This issue is used for outlining the design and scope of the initial package release onto PyPI.

Design pattern

System model creation is done using a composite design pattern, whereby model elements are instantiated then subsumed by a Model object or model elements within a Model object. See "class diagram" tab of SysML.py UML for a structural breakdown of the working design pattern implementation.

Use cases

The long term vision is to provide automation support for two primary use cases:

• Multi-disciplinary Design Optimization
• Verification & Validation

See "use case diagram" tab of SysML.py UML

Package contents & features:

• sysml/system.py - This module contains the Model() class for creating Model objects that serve as a central namespace for subclasses of ModelElements (see Implement Model() class #3). Methods should also be callable from Model objects (see getters & setters for Model() class #12, RTM() 'Requirements Traceability Matrix' #15, & Model Validation #25 to_yaml() #6). Module should also contain a function for deserializing Model objects (see read_yaml() #7)

• sysml/element.py - This module contains the core language of SysML for creating subclasses of ModelElement objects (s.a., Package, Block, ConstraintBlock, Activity, Interaction, StateMachine, and Requirement). These objects are intended to be subsumed by Model objects (see Populate 'element.py' #11).

Usage

The following illustrates an example workflow, using the traditional pillars of SysML (i.e., structure, behavior, and requirements) in conjuction with two new pillars: analysis and verification & validation...

(See test_model.py for most up-to-date profile of unittests)

>>> import sysml

# Create a model object that will also serve as the root directory for all other model elements
>>> model = sysml.Model()

Structure

# Create a package, labeled 'Structure' within model which will serve as namespace for the system structure
>>> struct_pkg = sysml.Package('Structure')
>>> model.add(struct_pkg)

# Model and Package objects can be thought of as a dict-like container for returning model elements
>>> model['Structure'] # should return a package object with str, «package» Structure

# model elements use python-ic dict-like setters for adding other model elements
>>> starship = sysml.Block('Constitution-class starship')
>>> model['Structure'].add(starship)
>>> model['Structure']['Constitution-class starship'] # should return a block object with str, «block» Constitution-class starship

# Block elements have attributs, such as parts, for storing subcomponents
>>> saucer_sec = sysml.Block('Primary Hull')
>>> engineering_sec = sysml.Block('Secondary Hull')
>>> model['structure']['constitution-class starship'].parts['saucer section'] = saucer_sec
>>> model['structure']['constitution-class starship'].parts['engineering'] = engineering_sec

# Parts added to a block element are dictionary-callable via the 'parts' attribute
>>> model['structure']['Constitution-class starship'].parts['Primary Hull'] # should return a block object with str, «block» Primary Hull
>>> model['structure']['Constitution-class starship'].parts['Engineering Hull'] # should return a block object with str, «block» Engineering Hull

Requirements

# Create a package, labeled 'Requirements', within model which will serve as namespace for the system requirements
>>> req_package = sysml.Package('Requirements')
>>> model.add(req_package)

# Define two requirement elements, passing in a string name and text field as its constructor arguments
>>> top_req = sysml.Requirement('Top-level', 'A constitution-class starship shall provide a 5-year mission capability to explore strange new worlds, to seek out new life and new civilizations, and to boldly go where no one has gone before.')
>>> func_req = sysml.Requirement('Functional', 'A constitution-class starship shall be able to travel at warp 8 or higher')
>>> model['Requirements'].add(top_req)
>>> model['Requirements'].add(func_req)

# Define a dependency relationship, of stereotype «derive», between two requirements
>>> deriveReq1 = sysml.DeriveReqt(top_req, func_req)
>>> model['Requirements'].add(deriveReq1)

Behavior (WIP)

# Create a package, labeled 'Behavior', within model which will serve as namespace for the system behavior
>>> behavior_pkg = sysml.Package('Behavior')
>>> model.add(behavior_pkg)
>>> warpdrive_testcase = sysml.TestCase('Warp drive operation')
>>> model['Behavior'].add(warpdrive_testcase)

Analysis (WIP)

# Create a package, labeled 'Analysis', within model which will serve as namespace for the system analysis
>>> analysis_pkg = sysml.Package('Analysis')
>>> warpfieldsim_interaction = sysml.TestCase('Warp field simulation') # Create a test case for verifying one or more system requirements allocated to it.
>>> model.add(analysis_pkg)
>>> model['Analysis'].add(warpfieldsim_interaction)

# A dependency relationship, of stereotype «trace», can be defined to relate the analysis test case to the behavioral test case
>>> warpdrive_operation = sysml.Activity('Warp drive operation')
>>> dependency2 = sysml.Dependency(warpfieldsim, warpdrive_operation, 'trace')

Verification & Validation (WIP)

>>> warpdrive = sysml.Block('class-7 warp drive')
>>> model['Structure']['Constitution-class starship'].part['warpdrive'] = warpdrive

# Define a dependency relationship, of stereotype «satisfy», to relate a structural element to one or more of its corresponding requirements that it satisfies
>>> satisfy1 = sysml.Satisfy(func_req, warpdrive)
>>> model['Requirements'].add(satisfy1)

# Define a dependency relationship, of stereotype «verify», to relate a test case to one or more of its corresponding requirements that it verifies
>>> verify1 = sysml.Verify(functional_req, warpfieldsim_interaction)
>>> model['Requirements'].add(verify1)

# Perform validation on system model, using built-in validation method, or generate a requirements traceability matrix (RTM)
>>> model.isValid() # returns True if all requirements are satisfied by a block and verified by a test case
>>> model.rtm() # generates an RTM

Additional features being considered in the development pipeline include, but not limited to:

• Diagram generators for the 9 SysML diagrams (see "diagram object" generators #10)
• Integration/plugin for OpenMDAO (see OpenMDAO integration #28 )