Jupyter-SysML v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Toward an Engineering Notebook for Systems Modeling\n",
    "\n",
    "## *Ed Seidewitz, Model Driven Solutions, Chief Technology Officer*\n",
    "\n",
    "&copy; Copyright 2019, 2023 Model Driven Solutions, Inc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Systems Modeling Language™ (SysML<sup>®</sup>)\n",
    "Supports the specification, analysis, design, and verification and validation of complex systems that may include hardware, software, information, processes, personnel, and facilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### SysML v1.0 adopted in 2006\n",
    "Adopted by the Object Management Group (OMG) as a standard profile of UML v2.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### SysML v1.7 adopted in 2022\n",
    "(https://www.omg.org/spec/SYSML/1.7/Beta1)\n",
    "\n",
    "v1.7 is expected to be the last for SysML v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### SysML v2.0 Beta adopted in 2023\n",
    "(https://www.omg.org/spec/SYSML/2.0/Beta1)\n",
    "\n",
    "Finalization is expected to be complete in 2024."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SysML v2 Pilot Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Developed incrementally\n",
    "The pilot implementation was developed incrementally by the SysML v2 Submission Team (SST) while working on the language specification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Open source\n",
    "Available at https://github.com/Systems-Modeling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Implements editing of textual notation, with some basic graphical visualization\n",
    "SysML v2 has a complete textual as well as graphical notation\n",
    "\n",
    "But the textual notation can be implemented more quickly and incrementally than graphical notation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Project Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\"Project Jupyter exists to develop open-source software, open-standards, and services for interactive computing\" (http://jupyter.org)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Interactive programming\n",
    "Originally based on the Python programming language\n",
    "\n",
    "Now supports \"dozens of programming languages\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Jupyter Notebook\n",
    "\"The Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text.\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Jupyter and SysML v2\n",
    "The SysML v2 textual notation is integrated as another Jupyter \"language kernel\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Goals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*Near term*\n",
    "* A way to quickly create SysML v2 models\n",
    "* A \"no install\" platform to track the latest incremental releases of the language \n",
    "  * via the JupyterHub deployment available to SST members at http://jupyter.openmbee.org"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*Long term*\n",
    "* A model-based engineering analysis environment\n",
    "* A means to interchange and integrate system engineering models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Mass Rollup Demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Massed Things\n",
    "\n",
    "To create a simple mass rollup example, we first define the general concept of a `MassedThing` with two mass attributes:\n",
    "* `mass` - The mass of the thing itself, not including the mass of any composite parts it may have.\n",
    "* `totalMass` - The total mass of the thing, including the mass of its composite parts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PartDefinition MassedThing (93ff128e-c180-4a15-a101-c5f72829652e)\n"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "part def MassedThing {\n",
    "    attribute mass :> ISQ::mass; \n",
    "    attribute totalMass :> ISQ::mass;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Simple and Composite Things\n",
    "\n",
    "Next we define two kinds of usages of `MassedThing`:\n",
    "* `simpleThing`, which has no composite parts, so its `totalMass` is just the same as its `mass`.\n",
    "* `compositeThing`, which has composite parts (`subcomponents`), so its `totalMass` is the some of its `mass` plus the `totalMass` of all its composite parts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PartUsage simpleThing (818ca0a2-ed47-48c4-b042-b6c6591c1d1d)\n",
       "PartUsage compositeThing (8c111cf0-bf98-4794-8e96-a1d881a89f09)\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "part simpleThing : MassedThing {\n",
    "    attribute redefines totalMass = mass;\n",
    "}\n",
    "\n",
    "part compositeThing : MassedThing {\n",
    "    import NumericalFunctions::sum; \n",
    "    \n",
    "    part subcomponents: MassedThing[*];\n",
    "\n",
    "    attribute redefines totalMass =\n",
    "        mass + sum(subcomponents.totalMass); \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Spacecraft Components and Systems\n",
    "\n",
    "Then we can apply the general model to specify that a `SpacecraftComponent` is a `MassedThing` and a `spacecraftSystem` is a composite `SpacecraftComponent` (that is, both a `SpacecraftComponent` _and_ a `compositeThing`) whose `subcomponents` are its `subSystems`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PartDefinition SpacecraftComponent (4c61b269-d4d2-4ed4-9468-0ab1dd97f2df)\n",
       "PartUsage spacecraftSystem (a5a4d878-7a21-4b2c-9c80-4eb24e59d87b)\n"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "part def SpacecraftComponent :> MassedThing {\n",
    "    attribute identifier: Scalarattributes::String;\n",
    "}\n",
    "\n",
    "part spacecraftSystem: SpacecraftComponent :> compositeThing {\n",
    "    part subsystems[*] :> spacecraftSystem redefines subcomponents;    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Spacecraft Decomposition\n",
    "\n",
    "A `spacecraft` is just a top-level `spacecraftSystem` whose subsytems are the main spacecraft systems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [
     0,
     4
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PartDefinition PropulsionSystem (71435e84-8ede-459b-911c-b7b140cdbf4a)\n",
       "PartDefinition PowerSystem (4cff8278-0c94-4203-839a-306c79703192)\n",
       "PartUsage spacecraft (a00ef966-cf88-4aac-a8ae-758f80609b7c)\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "part def PropulsionSystem :> SpacecraftComponent { \n",
    "    // ...\n",
    "}\n",
    "\n",
    "part def PowerSystem :> SpacecraftComponent { \n",
    "    // ...\n",
    "}\n",
    "\n",
    "part spacecraft :> spacecraftSystem {\n",
    "    part propulsion: PropulsionSystem subsets subsystems;    \n",
    "    part power: PowerSystem subsets subsystems;\n",
    "    // etc...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Specific Spacecraft Configuration\n",
    "\n",
    "A configuration for a specific spacecraft gives the masses for each of the subsystems – and can even add additional subsystems as appropriate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PartUsage spacecraft_1 (9d68fb69-e45f-4c39-899c-625aabd1b079)\n"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "part spacecraft_1 :> spacecraft {\n",
    "    import SI::*;\n",
    "    \n",
    "    redefines mass = 1000 [kg];\n",
    "    \n",
    "    part redefines propulsion {\n",
    "        redefines mass = 100 [kg];\n",
    "    }\n",
    "    \n",
    "    part redefines power {\n",
    "        redefines mass = 50 [kg];\n",
    "        part battery subsets subsystems {\n",
    "            redefines mass = 10 [kg];\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If the `spacecraft_1::totalMass` was properly evaluated above, the result should be `1160.0 [kg]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Vehicle Model Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "code_folding": [
     2,
     34,
     41,
     46,
     84,
     119
    ],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Package VehicleModel_1 (55014707-2689-4d29-88f6-3ecef98d08a2)\n"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package VehicleModel_1{\n",
    "    package ModelLibrary{\n",
    "        package PartDefinitions{\n",
    "            part def Vehicle {\n",
    "                attribute mass :> ISQ::mass;\n",
    "            }\n",
    "            part def Engine;\n",
    "            part def Cylinder;\n",
    "            part def Transmission;\n",
    "            part def Driveshaft;\n",
    "            part def AxleAssembly;\n",
    "            part def Axle;\n",
    "            part def FrontAxle:>Axle{\n",
    "                attribute steeringAngle:ScalarValues::Real;\n",
    "            }\n",
    "            part def HalfAxle;\n",
    "            part def Differential;\n",
    "            part def Wheel;\n",
    "        }\n",
    "        package PortDefinitions{\n",
    "            port def FuelCmdPort;\n",
    "            port def DrivePwrPort;\n",
    "            port def ClutchPort;\n",
    "            port def ShaftPort_a;\n",
    "            port def ShaftPort_b;\n",
    "            port def ShaftPort_c;\n",
    "            port def ShaftPort_d;\n",
    "            port def DiffPort;\n",
    "            port def AxlePort;\n",
    "            port def AxleToWheelPort;\n",
    "            port def WheelToAxlePort;\n",
    "            port def WheelToRoadPort;\n",
    "            port def VehicleToRoadPort;\n",
    "        }\n",
    "        package FlowDefinitions{\n",
    "            // This defines Torque as an alias for ISQ::Torque.\n",
    "            alias Torque for ISQ::TorqueValue;\n",
    "            attribute def FuelCmd;\n",
    "        }\n",
    "        package InterfaceDefinitions{\n",
    "            import PortDefinitions::*;\n",
    "            interface def EngineToTransmissionInterface{\n",
    "                end p1:DrivePwrPort;\n",
    "                end p2:ClutchPort;\n",
    "            }\n",
    "        }\n",
    "        package ActionDefinitions{\n",
    "            import FlowDefinitions::*;\n",
    "            action def ProvidePower {\n",
    "                in fuelCmd:FuelCmd;\n",
    "                out wheelToRoadTorque:Torque[2];\n",
    "            }\n",
    "            action def GenerateTorque {\n",
    "                in fuelCmd:FuelCmd;\n",
    "                out engineTorque:Torque;\n",
    "            }\n",
    "            action def AmplifyTorque {\n",
    "                in engineTorque:Torque;\n",
    "                out transmissionTorque:Torque;\n",
    "            }\n",
    "            action def TransferTorque {\n",
    "                in transmissionTorque:Torque;\n",
    "                out driveshaftTorque:Torque;\n",
    "            }\n",
    "            action def DistributeTorque {\n",
    "                in driveshaftTorque:Torque;\n",
    "                out wheelToRoadTorque:Torque[2];\n",
    "            }\n",
    "        }\n",
    "        package attributeDefinitions{\n",
    "            import ScalarValues::*;\n",
    "        }\n",
    "    }\n",
    "    package VehicleConfigurations{\n",
    "        import SI::kg;\n",
    "        import ModelLibrary::**;\n",
    "        \n",
    "        package VehicleConfiguration_a{\n",
    "            package VehiclePartsTree{\n",
    "                part vehicle_a:Vehicle{\n",
    "                    attribute redefines mass=1750[kg];\n",
    "                    part frontAxleAssembly : AxleAssembly {\n",
    "                        part frontAxle:Axle;\n",
    "                        part frontWheels:Wheel[2];\n",
    "                    }\n",
    "                    part rearAxleAssembly:AxleAssembly {\n",
    "                        part rearAxle:Axle;\n",
    "                        part rearWheels:Wheel[2];\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "            package VehicleActionTree{\n",
    "                \n",
    "            }\n",
    "        }\n",
    "        package VehicleConfiguration_b{\n",
    "            import VehicleConfiguration_a::*;\n",
    "            import VehicleConfiguration_a::VehiclePartsTree::*;\n",
    "            package VehiclePartsTree{\n",
    "                part vehicle_b :> vehicle_a{\n",
    "                     attribute redefines mass=2000[kg];\n",
    "                    /*adding ports to parts. will add ports to part defs later and redefine here*/\n",
    "                    port fuelCmdPort:FuelCmdPort;\n",
    "                    port vehicleToRoadPort:VehicleToRoadPort{\n",
    "                        port wheelToRoadPort1:WheelToRoadPort;\n",
    "                        port wheelToRoadPort2:WheelToRoadPort;\n",
    "                    }\n",
    "                    perform VehicleActionTree::providePower;\n",
    "                    part redefines frontAxleAssembly{\n",
    "                        port shaftPort_d:ShaftPort_d;\n",
    "                        part frontAxle:FrontAxle redefines frontAxle;\n",
    "                        part frontWheel1:>frontWheels=frontWheels#(1);\n",
    "                        part frontWheel2:>frontWheels=frontWheels#(2);\n",
    "                    }\n",
    "                    part redefines rearAxleAssembly{\n",
    "                        port shaftPort_d:ShaftPort_d;\n",
    "                        perform VehicleActionTree::providePower.distributeTorque;\n",
    "                        part differential:Differential{\n",
    "                            port shaftPort_d:ShaftPort_d;\n",
    "                            port leftDiffPort:DiffPort;\n",
    "                            port rightDiffPort:DiffPort;\n",
    "                        }\n",
    "                        part redefines rearAxle{\n",
    "                            part leftHalfAxle:HalfAxle{\n",
    "                                port leftAxleToDiffPort:AxlePort;\n",
    "                                port leftAxleToWheelPort:AxlePort;\n",
    "                            }\n",
    "                            part rightHalfAxle:HalfAxle{\n",
    "                                port rightAxleToDiffPort:AxlePort;\n",
    "                                port rightAxleToWheelPort:AxlePort;\n",
    "                            }\n",
    "                        }\n",
    "                        part rearWheel1:>rearWheels=rearWheels#(1){\n",
    "                            port wheelToAxlePort:WheelToAxlePort;\n",
    "                            port wheelToRoadPort:WheelToRoadPort;\n",
    "                        }\n",
    "                        part rearWheel2:>rearWheels=rearWheels#(2){\n",
    "                            port wheelToAxlePort:WheelToAxlePort;\n",
    "                            port wheelToRoadPort:WheelToRoadPort;\n",
    "                        }\n",
    "                        bind shaftPort_d=differential.shaftPort_d;\n",
    "                        connect differential.leftDiffPort to rearAxle.leftHalfAxle.leftAxleToDiffPort;\n",
    "                        connect differential.rightDiffPort to rearAxle.rightHalfAxle.rightAxleToDiffPort;\n",
    "                        connect rearAxle.leftHalfAxle.leftAxleToDiffPort to rearWheel1.wheelToAxlePort;\n",
    "                        connect rearAxle.rightHalfAxle.rightAxleToDiffPort to rearWheel2.wheelToAxlePort;\n",
    "                    }\n",
    "                    part engine:Engine{\n",
    "                        port fuelCmdPort:FuelCmdPort;\n",
    "                        port drivePwrPort:DrivePwrPort{\n",
    "                            out engineTorque:Torque;\n",
    "                        }\n",
    "                        part cylinders:Cylinder[4];\n",
    "                        perform VehicleActionTree::providePower.generateTorque;\n",
    "                    }\n",
    "                    part transmission:Transmission{\n",
    "                        port clutchPort:ClutchPort{\n",
    "                            in engineTorque:Torque;\n",
    "                        }\n",
    "                        port shaftPort_a:ShaftPort_a;\n",
    "                        perform VehicleActionTree::providePower.amplifyTorque;\n",
    "                    }\n",
    "                    part driveshaft:Driveshaft{\n",
    "                        port shaftPort_b:ShaftPort_b;\n",
    "                        port shaftPort_c:ShaftPort_c;\n",
    "                        perform VehicleActionTree::providePower.transferTorque;\n",
    "                    }\n",
    "                    bind vehicle_b.fuelCmdPort=vehicle_b.engine.fuelCmdPort;\n",
    "                    connect engine.drivePwrPort to transmission.clutchPort; \n",
    "                    interface engineToTransmissionInterface:EngineToTransmissionInterface\n",
    "                        connect p1::>engine.drivePwrPort to p2::>transmission.clutchPort{\n",
    "                             perform VehicleActionTree::providePower.generateToAmplify;\n",
    "                        }\n",
    "                    connect transmission.shaftPort_a to driveshaft.shaftPort_b; \n",
    "                    connect driveshaft.shaftPort_c to rearAxleAssembly.shaftPort_d;\n",
    "                    bind rearAxleAssembly.rearWheel1.wheelToRoadPort=vehicle_b.vehicleToRoadPort.wheelToRoadPort1;\n",
    "                    bind rearAxleAssembly.rearWheel2.wheelToRoadPort=vehicle_b.vehicleToRoadPort.wheelToRoadPort2;\n",
    "                }\n",
    "            }\n",
    "            package VehicleActionTree{\n",
    "                action providePower:ProvidePower{\n",
    "                    // No successions (control flows) between these actions, because the\n",
    "                    // flows between them are continuous streams.\n",
    "                    action generateTorque:GenerateTorque {\n",
    "                        in fuelCmd = providePower.fuelCmd;\n",
    "                        out engineTorque;\n",
    "                    }\n",
    "                    flow generateToAmplify from generateTorque.engineTorque to amplifyTorque.engineTorque;\n",
    "                    action amplifyTorque:AmplifyTorque {\n",
    "                        in engineTorque;\n",
    "                        out transmissionTorque;\n",
    "                    }\n",
    "                    flow amplifyToTransfer from amplifyTorque.transmissionTorque to transferTorque.transmissionTorque;\n",
    "                    action transferTorque:TransferTorque {\n",
    "                        in transmissionTorque;\n",
    "                    }\n",
    "                    action distributeTorque:DistributeTorque;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## \"Magic\" Commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Showing Elements\n",
    "\n",
    "The `%show <name>` \"magic\" command shows the parsed syntax tree for the named element.\n",
    "```sysml\n",
    "part spacecraft :> spacecraftSystem {\n",
    "    part propulsion: PropulsionSystem subsets subsystems;    \n",
    "    part power: PowerSystem subsets subsystems;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PartUsage spacecraft (a00ef966-cf88-4aac-a8ae-758f80609b7c)\n",
       "  [Subsetting] PartUsage spacecraftSystem (a5a4d878-7a21-4b2c-9c80-4eb24e59d87b)\n",
       "  [FeatureMembership] PartUsage propulsion (51f3f492-a9f1-4398-953a-16d90f410b82)\n",
       "    [FeatureTyping] PartDefinition PropulsionSystem (71435e84-8ede-459b-911c-b7b140cdbf4a)\n",
       "    [Subsetting] PartUsage subsystems (1597d02c-da90-4741-a551-ebff5362d496)\n",
       "  [FeatureMembership] PartUsage power (eea96d6c-fb8d-4d7f-be80-d2200b82d87d)\n",
       "    [FeatureTyping] PartDefinition PowerSystem (4cff8278-0c94-4203-839a-306c79703192)\n",
       "    [Subsetting] PartUsage subsystems (1597d02c-da90-4741-a551-ebff5362d496)\n"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%show spacecraft"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Publishing Models\n",
    "\n",
    "The `%publish <name>` command \"publishes\" the model graph rooted in the named element to a prototype repository via the proposed standard API. \n",
    "\n",
    "* The API endpoint currently used is for a single, publicly available instance of the repository.\n",
    "* All elements directly *and* indirectly accessible from the specified root element are saved (but not indirectly referenced standard library elements).\n",
    "* Each publish of a model creates a new copy in the repository."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "(This cell is currently disabled to prevent accidental publishing.)\n",
    "%publish spacecraft"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "SysML",
   "language": "sysml",
   "name": "sysml"
  },
  "language_info": {
   "codemirror_mode": "sysml",
   "file_extension": ".sysml",
   "mimetype": "text/x-sysml",
   "name": "SysML",
   "pygments_lexer": "java",
   "version": "1.0.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}