This is the second of two videos that explores how Jazz-based Rhapsody Model Manager workings have changed in the 3 releases from 6.0.6 to 7.0.1. It follows on from tip #88. The main change is that the /am functionality is now provided as an extension to the /ccm application. This means that work items and model management are stored in the same repository. There is also a new license that enables the /ccm server to be used for either just Rhapsody models, or Rhapsody models and source code. In this caption-based video I look at a few aspects of using 7.0.1, including associating changes to work items, and being able to do more functions like accepting change sets directly from the Rhapsody browser. I also recap how to establish links to requirements in the IBM Engineering Requirements Management DOORS Next application (/rm) - although this is not new.
Friday, 20 November 2020
IBM Engineering Rhapsody Tip #89 - Exploring how RMM has changed, 6.0.6 to 7.0.1 - Part 2 of 2 (Intermediate)
Thursday, 12 November 2020
IBM Engineering Rhapsody Tip #88 - Exploring how RMM has changed, 6.0.6 to 7.0.1 - Part 1 of 2 (Intermediate)
One of the areas where the IBM Engineering Rhapsody development invested a lot of effort in the last 3-4 releases is in its integration into the IBM Jazz platform with the Rhapsody Model Manager (RMM) server-side technology. This is crucial, of course, for its integration with DOORS Next generation, IBM's web-based Requirements Management (RM) technology built on top of Jazz. RMM also enables web views of the model and linking with work items and planning and shared configured access to models. In version 7 of Jazz there was a significant change, in that the functionality provided by the /am application became an extension to the /ccm application, rather than a separate entity. Over the releases they've also done work to make more functionality available directly in the Rhapsody browser. In this first of two videos, I wanted to give some examples of things that have changed (especially to those who are user older versions and thinking of migrating).
This week I did another (free) workshop with the engineering apprentices on Requirements Management. I learnt that there's hope for Star Wars yet. At least one 3 year girl with Star Wars wallpaper, duvet and a Lightsaber (I think this is a new hope?). I think this means it's just skipping a generation.
What else? Well, requirements can get a bit messy to begin with, especially if you're messing around with different tools - Teams whiteboards/Google jamboards (hey that's like reality till you get proper in place right ;-).
I also learnt that engineering apprentices are more creative at creating requirements for an Ironman suit than I am (no surprise there). Alas, I didn't get them all into an RM tool in time though.
Also, a well timed Kahoot quiz, leaves nowhere to hide ;-) This is actually quite a fun thing to do with online training. I might do a bit more using this going forward.
Last week I did some (free) MBSE awareness training with some engineering apprentices. I learnt that "star wars" is not a thing. Apparently, there is a film called "ironman" that I should've watched and that ironman is not ironman until he puts on some "special" suit, and that the suit actually can make it's own decisions (which is important to know upfront but sounds a bit dangerous to me ;-)
Subsequently, I did find out from Barclay Brown that Jarvis (actually an acronym) is the AI that Tony uses, and is distributed with parts of it executing in the suit and parts executing on servers in Tony's Malibu basement or elsewhere in the cloud we hope, at least when the Malibu house is destroyed. In any case, Jarvis should be an actor. Also, the suit is able to communicate with and control other suits (depending on which movie you are referencing). The suit may also communicate with some kind of enclosure, like the briefcase in Ironman 3 (?), though the briefcase could perhaps be considered part of the suit, especially if it goes WITH the suit after suit deployment. For yet more subtlety, it seems that the suit can have a 'guest' wearer, who is more like a passenger, with the suit being controlled externally, such as when Tony puts the suit on Pepper to protect her from the attack on the house, so perhaps guest/passenger should be an actor!
Wednesday, 28 October 2020
This IBM Rational/Engineering Rhapsody tips and tricks videos follows on from the previous video (#86) on the SysML Profile's part browser. This video covers how it's possible to create your own "browse hierarchy' submenu's to launch browsers based on different context patterns. In this example I create a new browser for viewing traceability to requirements that mimics the Rhapsody Gateway's impact analysis view but doesn't require use of the Add On. I show use of the context pattern, including navigating reverse direction of a dependency (thanks' to Andy Lapping's digging in this area) and then use of a plugin method as part of the context pattern (I need to keep it as geeky as possible ;-). By extending Rhapsody with my own profiles, I'm able to focus SysML to specific tasks, making it easier for users to get higher business value earlier in their adoption lifecycle.
This caption-only advanced-level tip follows on from video #86.
The SysML Profile's parts browser provides an example of how Rhapsody can build a custom browser using a context pattern.
Let's create a custom browser for showing requirements traceability instead!
This Executable MBSE project has lots of traceability to requirements.
Conventionally, I may have used an add-on such as the Rhapsody Gateway to view such traceability. This can take a while to load though.
Let's add a new browser to do this in Rhapsody instead. To add a new browser we need to create new properties. The New property button is not visible by default (it requires a rhapsody.ini tweak).
Top tip: Never edit the .ini file with Rhapsody open and always create a backup!
To add properties via the UI we need to add ShowPropertiesButtonFromPropertiesPage=TRUE to the rhapsody.ini file.
To know which properties to create, I'll use the SysML profile as a guide. 3 properties are needed for each metaclass for which a right-click menu is desired.
Firstly, I'll create a Model::Project::BrowseHierarchy property on the Project metaclass.
We'll define the value to make BrowseTraceability the [key] for the menu.
Now, I'll add a property using the [key] called Model::Project::BrowseTraceabilityName.
This will define "Browse Traceability" as the name of the sub-menu to add.
I now need to specify the context pattern. I'll create a Model::Project::BrowseTraceabilityPattern property for this.
A context pattern is a way to describe a path of elements in the model. It's a comma-separated list of tokens. E.g., Look for nested packages, when you find a package, look for requirements.
Let's see if it worked?
Here's the new Browse Traceability menu!
The browser contains all of the packages (not just packages with requirements).
Let's tweak the pattern. * means zero or more, whereas + means 1 or more.
That's better. The browser is now only showing packages that own requirements.
Next up, I want to find elements that trace to the requirements. This line says look at references which are dependencies and then go to the element that owns the dependency.
We can now see the elements that trace to the requirements. However, the dependency relation is also shown.
As a final example of tweaking, I'm going to use a plugin method. A plugin is a way to extend Rhapsody with Java code. Plugins run in the Rhapsody process.
This Java method is in my RPUserPlugin class for my Executable MBSE profile.
I'll replace the references check with this plugin method instead.
The element list below the requirement is now being created by the plugin method.
Job done! This view is rather similar to the Gateway's Impact Analysis view but I don't need to leave Rhapsody ;-)
Interested in advanced training or customizations? Email me.
Friday, 23 October 2020
I wanted to show how it's possible to create a custom requirement traceability browser in Rhapsody. First off, though, it's worth understanding the Parts Browser in Rhapsody; a feature added by Rhapsody's factory SysML profile. The parts browser allows you to launch a browser to drill down a Block/part hierarchy tree. The parts browser is available as a submenu on the right-click 'Browse Hierarchy' menu The browser is formed using a context pattern which defines how to traverse relationships in the model to form the browser. In this short, caption-based (i.e. silent) video, I show how it works and then look at some of the properties behind it. In the next video in this series, I'll show how it's possible to use a similar technique to create a browser for showing requirements traceability.
Thursday, 15 October 2020
Interested in a model repository and sharing platform for many different types of modeling tools, not just Rhapsody? Check out the MID smartfacts technology:
Background: IBM Rational brand originally worked on the Design Manager repository-based technology, an ontological database with a Jazz-based client for web-based access. Originally they moved it to support their Java-modeling Rational Software Architect (RSA) tool. They then acquired Telelogic and began adapting it for Rhapsody, ultimately shipping a Rhapsody Design Manager (RDM) variant. At the same time a web-publishing adapter was also available for MathWorks Simulink models and was covered under the RDM licensing. With the move away from repository-based to the file-based Rhapsody Model-Manager technology (RMM), the Simulink aspect (and ability to write adapters to other tools) got dropped, potentially leaving a gap for companies interested in a library and linking capability for a range of tools. Could smartfacts plug this gap?
Wednesday, 14 October 2020
I'm exploring the idea of running an evening/weekly call-type class or self-paced class for contractors/people looking to upskill with SysML/Rhapsody/MBSE knowledge. It's not entirely clear how much interest there would be in this, so I will do a trial if I can get enough interest. If you are interested let me know. I've updated the form here to give it as an option.
A bit of background: Historically my training focus has been business-to-business, e.g. running private Rhapsody training for companies adopting the tools on either a one-off or a series basis. I did have a lot of success with open training run in conjunction with HORIBA MIRA but Covid-19 and other reasons have put a hold on face-to-face training. It can also be hard for individuals (contractors and engineers looking for personal development) to access such training as it requires a lot of commitment of time. I'm therefore thinking of some lighter-weight, more lower cost options that I could deliver now while lots of people are working from home, and across a broad geography (particularly outside the UK).
Friday, 9 October 2020
Ok, I'm back into more regular update videos. This again, is a slightly more advanced topic, although it also explains a little about what SysML proxy ports and Interface Blocks are and one of the ways they differ from standard UML ports and interfaces. This IBM Engineering tips and tricks video follows on from video #85 and shows how to get flow properties and change events to simulate with SysML proxy ports. The key thing is that in addition to using the change event and the auto-generated setter, you need to set both ports as behaviour ports. This is actually picked up by the Rhapsody model checker as a warning, as this short (and caption-driven, i.e. silent) video illustrates.
Thursday, 1 October 2020
Training from last week was interesting. I realized just how much there is to take in when adopting model-based systems engineering for the first time. Enthusiastic people definitely help, not just engineers but also management giving them their support. It's not just knowing the ins and outs of the tools (both the modeling tool and how it integrates with others) either, there are so many aspects to the language and many ways to use it. It was good that we finished with workshop that looked at an example process though. I think when you see an end to end example built around your problem then it helps people appreciate how an appropriately selected process can significantly improve requirements definition and systems architectural work.
This short and silent caption-based tips and tricks video came from a subscriber emailing me for help on getting change events to execute correctly with SysML proxy ports. In this first of two videos, I thought I'd recap some of the fundamentals about how change events in Rhapsody statecharts work, and what they're for. The key tips in this video are really that you need to make sure that you use the setter operation when changing the value of attributes / value properties. Setters and getters (what are often called a mutators and accessors in C++) are auto-generated. The setter will follow the convention of the word set followed by the name of the attribute capitalized. Change events are used as triggers in Rhapsody statecharts for reacting to a change of data. They also follow a naming convention which is the characters 'ch' (for change) followed by the name of property (capitalized). Hopefully the video explains for those who're interested!
Here's an interesting link for people who might be interested in thinking outside the box (so to speak ;-). It seems that John Brush has ideas for visualizing SysML diagrams in more interesting and domain-specific ways, e.g., as electrical circuit diagrams!Something to discuss at an INCOSE MBSE working group meeting, perhaps ;-)
Tuesday, 22 September 2020
If anybody has a deep interest in Rhapsody support for OMG's Unified Architecture Framework® (UAF®) then this link to Graham's blog may be useful: https://jazz.net/library-content/index.php/preview/95889 . The work is ongoing but Graham's included a download.
The Unified Architecture Framework is based on the Unified Profile for DoDAF and MODAF™ (UPDM™) and defines ways of representing an enterprise architecture. The UAF enables stakeholders to focus on specific areas of interest in the enterprise while retaining the big picture and builds on standards such as UML and SysML.
Monday, 21 September 2020
One of my earliest IBM Rational Rhapsody videos ends with a demo that shows a customisation I made to my SysMLHelper profile around 5 years ago (video tip #8) to Rhapsody enhanced tooltip feature. It doesn't go into detail about how I achieved it though and a few people have asked. Actually, in doing this video I realize that the property I used to hook the plugin method into the profile is no longer documented in the product, which is why people have asked! It still seems to work though (up to 9.0.1) hence I've put together this "under the hood" look video. The property is called Model::Stereotype::ModelTooltipPluginMethod. This 5 min video, for advanced users of Rhapsody, also gives a bit of a look at the role of customizing Rhapsody with Java plugins, profiles, and properties. This video is a silent one, i.e. you'll need to read the captions to understand it.
Tuesday, 25 August 2020
This is one of my more involved and narrated videos. It covers the topic of domain specific profiling with IBM Rational Rhapsody. In it, I give a glimpse of an example profile for automotive model-based systems engineering, showing how it's possible to add new term element types and diagrams to make SysML/UML more easily consumable when following a chosen method. Domain specific profiling in Rhapsody is controlled via properties on stereotypes. At the end I also show one of the more advanced techniques I've moved to is to build and maintain such a profile using model-based techniques, i.e., drawing a class model of the domain specific meta-model that represents the element types (also known as meta-modeling! ;-).
Here's the transcipt:
In this video I thought I’d give a short insight into what a domain specific profile is. Some of the benefits… and how I go about this in Rhapsody now, based on my experience.
Firstly, a profile is type of package that extends the UML language. Profiles contain stereotypes to represent new concepts and meanings. Profiles can also add tags and, in the case of Rhapsody can convey properties that change the user interface.
SysML, for example, is a profile that extends UML, and it contains a stereotype called a Block. Whilst a block in SysML is a general-purpose element for architectural specification, within any given model there likely to be different types of blocks. We could further classify or replace the idea of a Block using stereotypes of our own.
For example, here I have the prototype for a profile I’m dubbing as my 'Autobahn Profile' as it’s designed to speed up the journey into productive model-based systems engineering, and builds on my automotive sector experience. In this profile some Blocks may represent systems while others may represent subsystems or functionality performed by subsystems.
Having created these stereotypes I can use them in the browser. Let’s create a logical system package with a logical system element inside it. Here the browser is representing these new term stereotyped elements as part of the tools’ modeling language, including given them their own categories and icons in the browser.
Stereotypes are a bit like fancy dress. We can stereotype base UML elements to give them new meaning.
With Rhapsody, unlike some of its competitors such as Cameo, the extension mechanism for writing a domain specific profile does not require you to write any code. It is based instead on static values set in profile and stereotype properties. The use of New terms like this Logical System stereotype I’ve added here, can be conveyed by the profile in such a way that they change the Rhapsody menus.
New term stereotypes can also be applied to diagrams. Here’s a stereotype I’ve used to create my own Architecture Definition Diagram type. The drawing toolbar for the diagram has be customised using properties on the stereotype. This enables me to add new classifications of element types to the drawing toolbar, but also subset default element types so that users are not burdened with unnecessary choices.
Let me quickly change this diagram back to the standard Object Model Diagram type. Here you can see if has options such as Objects, Classes, Associations, and Links. By applying the new term stereotype, I can specialise and simplify the available palette of tools. I’ve essentially created my own domain specific Block Definition Diagram type, albeit that I’ve further classifiers such as logical systems, logical subsystems and subsystem functions.
This makes it clearer and simpler for a non-SysML expert to draw a necessary structure, as they can work closely with more familiar terms.
A system comprises of subsystems, and subsystems own subsystem functions. By using this domain specific profile, I’ve made a choice about how to adapt the generic SysML language up front rather than leaving it to end users. This reduces the burden placed on end users to choose how to represent their concepts.
Using properties on the elements, I have also applied some more direct constraints. For example, subsystem functions can be used by subsystems and by not systems.
This makes it possible to achieve a more consistent outcome with less training. Such customisation's become valuable at scale when you start to deploy MBSE in a mass- user environment where black belt SysML experts are not 10 to a penny, rather everyone has a job to do and a limited time to do it.
In building a number of these profiles for different clients, one of techniques I’ve centred on is the use of different package types to simplify menus to role-based work. Here, for example, you can see that there are a number of different package types I’ve made available on the right-click menu for the project.
For example, I quite like the idea of a use case package, where the right-click menus are simplified for just elements needed for use case analysis. As I want use case analysis to be by a domain specialist, I’ve removed SysML types they don’t need like Blocks, Parts, and Ports. In this instance I haven’t actually added any new concepts. I’ve just simplified the menu so that the users working on these packages can focus on the job at hand.
I quite like this idea of sub-setting packages in this way. I also like the flatter, ordered structure that new term package types can give, so users do not have to drill too deep to find the area of the model they’re working on.
That’s just a very short introduction into what domain specific profiling is and some of the benefits such as easing adoption by domain specialists, improving the consistency of models, and simplifying training by removing the need for all end users to learn the full breadth of the UML and SysML languages.
I wanted to finish off by just giving you a glimpse of how I now approach building profiles like these for customers. As you can see here, the profile is specified using properties which formulate how the menu should be structured and what the context menu of an element should allow.
For small profiles these can be doctored by hand. What I found through experience is that manually keeping all these properties in synch becomes exponentially harder as you progressively add new terms, especially as names of things often change during the forging of a profile.
To solve this issue, I’ve created a meta-modeling profile and plugin to apply a model-based approach to building up the profile properties. This enables me to draw the relationships I want between meta-types and get the code to automatically update the corresponding property values. This makes it much more fun. For example adding a composition relation will allow a nesting in the browser and using an aggregation relation will add the element type to the drawing toolbar.
To illustrate this, let’s look at an example. Firstly, I’m going to add some new icons to the profile’s Rhapsody project. These will be used to represent a new type of package called an Actor Package. Actor Packages will perform the role of housing Actors shared by other packages, and will have their own icons to distinguish them in the browser.
I’ll now add a stereotype to represent the Actor Package type. I’ll make this a New Term stereotype applicable to the base UML Package type. Checking the New Term box tells Rhapsody that it needs add Actor Packages as a category in the browser, and also means that some properties applied to the stereotype will come into play.
Let’s use these properties to specify a new icon for Actor Package elements in the browser. I’ll also set this separate property that specifies which icon to use when displaying a category grouping elements of this type.
In general it’s better for stereotypes to not have spaces in their name as it makes managing the properties for them easier, so I’ve not used spaces in the browser, and will give the Actor Package a human readable name via its property instead.
I’ll also give it a category name for use in the Rhapsody browser. Using a number here is a trick that I use particular for new term packages, as it acts to order to the package types in the root of the Rhapsody browser, making them easy to find. This will become more obvious in a minute.
I’m now going to switch to the metamodel that I’m using to maintain the menu related properties. This is declared separate from the profile, using a class model, hence doesn’t need to be deployed to end users. As I mentioned, this metamodeling-based approach enables me to build the menu structures graphically. As I can’t draw class relationships between stereotypes I will use a stereotyped class in the model to represent the stereotype instead.
To begin with I need to add a class to represent the Actor Package. I’m using a stereotype in my metamodel profile to represent that this is a new term. I’ve draw a dependency to bind this class to the stereotype I want the properties to be updated for.
A number of classes are already specified in the metamodel for this profile. I want Actor Packages to be available on the right-click menu for the project, so I’m going to use a Composition relation to specify this. I’ll drag on the class representing the AutoMBSEProfile and draw the composition. I also want actor packages to be in the right-click menu for elements typed as use cases packages, so I’ll drag that concept in from the browser and draw another composition relationship.
Finally, I’m going to use a stereotype to say Actor Packages it should be placed in the AutoMBSE Element submenu. At this point I can run the plugin code that sets or updates the properties based on the metamodel I’ve specified here.
This can take a minute or so but is a lot quicker than trying to find all the necessary properties and update them by hand, especially when the number of terms becomes large, or you want to tweak or change their names. As you can see here, the meta-model plugin displays the aggregates properties for the new term element types in a simple table.
This allows me to spot mistakes. For example, my new actor package is missing some element types. I forgot to say that I want Actor Packages to contain actors, for example. To do this, I’ll drag in the UML Actor type from the base metamodel package. I can then draw a composition relationship to say that Actor packages can contain them.
There are also a number of types that I want all Packages to have such as Comments, Tags, Dependencies and Hyperlinks. Rather than draw these individually I’m going to specify these base relationships using a Generalisation relationship to a base Package type. My plugin code will look at the relations of the inherited metatype when forming the property values.
If things start to get complicated I can get Rhapsody to re-lay out this metamodel diagram with a hierarchical style.
Once I’m happy the desired relations are in place, I can then rerun the plugin to set the necessary properties on the stereotypes. This will include the property that determines the right-click menu structure. Again, this can take a while but is a lot easier to do with the profile doing the work for me.
Now we can see Actor Packages are on the right-click menu. By controlling the menus in this way, it’s easier to direct a team to produce more consistent output. Consistency about how projects or parts of projects are developed can also be valuable when chaining methods together, for example, taking the outcome of use case analysis and consuming them in further downstream analysis such as building an interaction model with executable state machines.
We can think of the team developing the model as a system, where different parts of the system work on different packages and hand off or consume artefacts of others.
Packages are also the default granularity for configuration management of Rhapsody models, and can be shared by reference between different projects.
This concludes the demo for now. The profile I’ve shown here is a prototype of my Autobaun profile, so if you’re interested to know more then let me know and I can maybe show you a few more details.
That’s it for now.
My name is Fraser Chadburn and I’m a specialist in model-based engineering with Rhapsody. As well as developing and delivering tool-based training for Rhapsody and IBM products, I specialise in providing consulting for clients to achieve higher value by extracting the best from their tools. If you do have any questions then feel free to drop us an email.
Monday, 3 August 2020
Tuesday, 21 July 2020
This short video (unusually with audio!) covers Package Diagrams one of the simplest structure diagrams that SysML inherits unmodified from UML. In general they show containment and dependency relationships between packages, although it's important to note that any of the structural elements might also be shown such as nested hierarchies of requirements or blocks.
The video covers some tips and tricks to get the most out of Rhapsody including setting the TreeContainmentStyle property depending on the style of containment relationship that you want to show. The video uses Rhapsody 9.0.1 (released July 7 2020).
Here's the transcript (in case people need additional info to help understand):
This is the seventh in my series of videos on the different diagrams in the UML and SysML languages. In this video, I’m going to cover how Package Diagrams are implemented in IBM Rhapsody.
Package diagrams - like use case, sequence, and state machine diagrams, are inherited into the Systems Modeling Language directly from the UML without modification.
The PDF I’m showing here is actually the first UML 2.0 spec from 2003. Here we can see that it states that there are no strict boundaries between the different structure diagram types, and it is possible to display elements such as objects, classes and packages, in any of the variations, it’s just that usually package diagrams are focused - as you’d expect - on packages.
If I switch to the UML menus in Rhapsody so that the SysML profile is not active, then you’ll notice that Rhapsody doesn’t have an explicit Package Diagram type, rather it expects an Object Model Diagram to be used for this purpose.
It does this on the basis that the Object Model Diagram drawing toolbar already allowed in 2003, the modeler to draw any of the structure diagram elements including objects, classes and packages.
If I switch back to the SysML menus, however, you’ll see that there is an explicit menu for a Package Diagram, and that the SysML profile has added this to Rhapsody’s pop-up menus.
Package diagrams are one of the simplest diagrams in the UML’SysML language.
Since all diagrams SysML have a diagram frame, the fact that this is a package diagram can be seen from the pkg abbreviation in the top left-hand corner of the frame.
Packages in Rhapsody are shown with a blue folder icon. They act like folders and are used to split up and organize model elements for access and understandability.
In the case of Rhapsody, they also map to separate units, or files, and hence form the basis of configuration management operations like check in and check out, and for sharing of common model elements between different projects.
Packages, like folders on a file system, can be nested underneath other packages. The package diagram allows useful groupings such as these to be visualised on a diagram.
If you try to show something out of context, then you can see here, that Rhapsody denotes this with a dashed line.
In this instance, I could right-click to change its ownership, in which case the browser will re-structured to match the diagram.
The Nesting style shown here is using Rhapsody’s default display option.
If we look in the latest SysML specification, Figure D.3 here shows us the two different containment notations. Both mechanisms shown here are possible in Rhapsody, but you may need to set a display property to get the top-one to work.
Let’s have a go at drawing this diagram. I’ll add a new package diagram to the HSUVModel package, but before doing anything else, I’m going to set a display property on the diagram called TreeContainmentStyle.
This notation style is also referred to as “alternative membership notation”. The property could be set at diagram, package, or project level.
It can be used to depict hierarchical relationships, not just with packages but also other model elements such as requirements, diagrams, and blocks.
With Tree Containment Style set, if I drag elements from the browser then the containment relationship will be populated on the diagram.
Before doing this, I’m just going to set the default display size for packages, to the one that I’ve got here. These means that when I drop elements on the diagram they’ll take this as their default size.
Notice that in 8.4 onward's I can drag a group of elements from the browser, by dragging the category to select them.
Here we can see that any existing containment relations we will automatically populated, if we drag something on to the diagram from the browser.
Conversely, If I remove the relationship in the model then the diagrams will be updated accordingly to remove the containment display, so that the diagram and model are always in sync.
If the related elements are already on the diagram, then we can choose to populate existing relationship using the Complete relations menu in the main Layout toolbar.
Notice that I can drag any model element on to the diagram.
For example, here is the containment relation shown between the HSUV Structure package and the Automotive Domain block.
The second form of the containment notation will still work with the TreeContainmentStyle property set. This is the default way of showing the HSUV Specification is underneath the HSUV Requirements package.
Package diagrams are also used to show other types of relationship between packages. Most commonly these are dependency relationships with stereotypes applied. The stereotypes could be built in or user-defined.
Here I am saying that the HSUV Use Cases package has a Usage dependency on elements in the HSUV Requirements package.
Profiles are types of packages and can be used on package diagrams in the same way.
If a profile is not globally applied but contains properties that you want to apply to only part of the project, then it can be applied to a package and its children using a built-in Rhapsody stereotype called AppliedProfile.
Sometimes I use colour to differentiate profiles from packages on the diagram. There are no conventions in the use of colour in SysML or Rhapsody, however. Of course, you must be careful in using colour alone as a reasonable proportion of the population is colour blind, hence other formatting could be used.
Don’t forget that you need to set the TreeContainmentStyle property if you want to show containment links on diagrams and that it’s perfectly possible for package diagrams to contain model elements other than packages.
There we have it. Package diagrams. One of the simplest structure diagrams that SysML inherits directly from UML without modification.
My name is Fraser Chadburn and I specialist in tool-based training and consulting in IBM products and in particular in setting up Rhapsody using domain-specific profiles.
Using Java automation, I can simplify and speed up modeling tasks so that users can focus on creative and fun systems and software engineering.
If you do have any questions, then feel free to email me.
Thursday, 16 July 2020
If you're looking for tool-based training in Rhapsody then let me know.
The SysMLHelper profile is a super-set of profiles and actually includes a number of different profiles that re-use a common Java code base:
a) A backwardly compatible update of the original v2.0 SysMLHelper profile
b) An ExecutableMBSE profile (my new term update to the original SysMLHelper), and
c) A FunctionalDesign profile (the first example of a few).
d) A Tau G2 model migration profile (work done for a specific customer).
I have a second stream of profile development underway focused on a function block-based Automotive Profile.
This new stream includes better meta-modelling support to make it easier to build Domain-Specific profiles with Rhapsody very quickly but is not yet available for distribution. This also follows the principal of re-using Java code for Rhapsody helpers so that it's quick to create customer-specific versions that are packed with usability features.
Wednesday, 8 July 2020
It's similar in thinking to some of the work I'm being doing this year with automotive customers. This work has "driven me" ;-) to use meta-modelling and advanced customisation techniques in Rhapsody to build custom profiles for automotive systems engineering with Rhapsody. It also highlights how automotive differs from other sectors in the way it "thinks" (particularly when it comes to functional safety and ISO 26262 although one could argue it both ways about the challenges of this).
Tuesday, 23 June 2020
Here's the transcript:
This short (and mostly silent) tips and tricks video came off the back of a recent webinar I delivered where an ex-IBM colleague commented about his favourite Rhapsody shortcut and I thought, why don't I use that? Anyway, here's a small selection to refresh our minds ;-)
Rhapsody includes various keyboard shortcuts (also known as accelerators). An accelerator key is a key (or combination of keys) designed to achieve a specific action.
Some of these are common to Windows applications but others may be specific to Rhapsody features such as diagram editing or controlling the workspace.
E.g., Edit > Select > Select Same Type is one of the tucked away menus I use a lot in Rhapsody! Ctrl+Alt+T is the shortcut for Select Same Type.
Ctrl+Alt+T selects all the elements of the same type, useful for using the Layout toolbar to align or space elements
Multi-select also enables you to set common display options, e.g., to show Description compartment in all the selected graph elements.
Ctrl+L is Navigate > Locate in browser.
Modifying with Shift, i.e. Ctrl+Shift+L, will Navigate > Locate on diagram.
If a diagram is selected then Ctrl+P will launch the print dialog.
Less familiar, did you know that Ctrl+R, will display the References for a selected element?
Rhapsody's Enhanced Tooltip is sometimes a useful feature (and sometimes not)...
There's some shortcut clues down here...
E.g., Ctrl+F2 will persisted the Enhanced Tooltip window.
Ctrl+Alt+F2 will toggle enhanced tooltip on and off.
Shift+Alt+F2 and it's off.
Shift+Alt+F2 again and it's on.
Another useful toggle is Ctrl+0 (zero). Ctrl+0 will hide/show the browser.
If we want to reset our workspace window layout then Ctrl+W will Window > Arrange Options.
Modifiers change the behavior of a command.
E.g. Delete will normally Remove from View, i.e. element is still in model!
Adding the Ctrl modifier, i.e., Ctrl+Delete, will Delete from model.
Modifiers also work with other commands
E.g. Ctrl+F is a conventional Windows shortcut for launching a Search dialog.
Shift+Ctrl+F will modify to Search in Diagram...
There are more, of course. However, do you know the shortcut for zoom to fit?
F6 will Zoom to fit for a diagram.
... and the Shift modifier, i.e., Shift+F6, does Undo Zoom to go back.
Tuesday, 16 June 2020
My 3rd and final in a series of live webinars on advanced MBSE techniques with #ibm #rhapsody is this Thursday at 14:00 (BST). This weeks topic is:
18th June @ 3pm CET - Simplifying SysML for the Real World.
Registration is via an IBM page: https://event.on24.com/wcc/r/2396520/1308314875BBD4EF2ABB05E0260ADC85