Multiplicity in Capella


I am currently building a model in Capella and I was wondering what the common practice of multiplicities is in Capella. I do have some SysML knowledge, and there it is quite easy to specify the multiplicity for each block. There are in my opinion 3 different types of multiplicities:

  1. A small number of items (e.g. exactly 2 batteries)
  2. A huge number of items (e.g. 100 or more components of something)
  3. A range (e.g. when you have not decided yet whether you want to use 2 or 3 batteries you can specify a range, in SysML: [2 … 3])

I have seen in other posts on this forum that the common way is to use REC/RPL, but that seems only applicable for option 1, since it makes no sense to me to replicate 100 elements (option 2) and it seems not possible to specify a range (option 3).

For option 2 I saw in another post that you could also specify a pattern, but then you would still have 100 components in your model and that feels not very efficient.

I would be glad if you could clarify more on option 2 and option 3.

Hi Jari,

I will try to reply to part of your question.

If I understood correctly your need, you are intending to define the multiplicity between a Whole and Part relationship, done in a Block Diagram Definition (SysML).

Creating an REC/RPL may not the best approach has the REC/RPL gathers a set of model elements that are intended to be reusable. It may suit the need to capture in a REC a set of several components and their components exchanges, or a functional chain, etc., and then replicate it as needed for the design.

However, I don’t think it is possible to define the multiplicity in a breakdown diagram similar to SysML.

It is possible to define the multiplicity in a class diagram, which again I don’t think it is what you are looking for to achieve.

Hi. For Option 3, you can always create a pattern (1 battery) and add a constraint specifying the range. Constraints are elements in the model, not comments. They can be considered as specifying artefacts.

PS: REC/RPL is a powerful mechanism that can indeed support the class-instances practice (very software oriented by the way) but also other general reuse practices. You may want to check out the first part of this webinar: [Webinar] Strategies and tools for model reuse with Capella (by Artal and Thales) - YouTube

@JNavas @HelderCastro Thanks for the explanation. I indeed intended to define the multiplicity as it is done in a Block Definition Diagram (BDD) in SysML.

I think the pattern is then the most efficient way to go. I do however have other questions about the REC/RPL feature.

  1. When I define a REC right now, it comes from a model element (e.g. a Component with a function or something like that), but is it also possible to define RECs outside of your model and then only use the RPLs in your model? I watched the video that you pointed me at Juan, and it seems that this is indeed possible, but I don’t know how to do it. Could you give me an example or explain the steps that need to be taken in order to achieve this?

  2. I also have some cases which are not ‘pure’ multiplicities; think of generalizations for example. I saw that there exist a generalization link for Class objects in Capella, but not for Components. From my current level of understanding this could also be achieved with REC/RPL, using a Compliancy Definition that is different from ‘BLACK_BOX’. However when I try to update the RPL from a REC it also changes the name(s) of the model elements. This might be intended by the way of how REC/RPL is defined, but can I change that? (and adding a suffix here does not work, since the name should be completely different) Also, please correct me if this is not the common way of handling generalizations of Components and Functions

Yes this is possible. You should create a Capella Library model and define the REC there. Then import the library into your project and replicate the RECs into your project.

1 Like

Yes, it is possible and for me it’s a very good practice : indeed it is easier to manage your RECs in the library and to instantiate them into your Capella project via RPLs. Because else in the same Capella project you have to manage your REC and your RPLs and it is not obvious ; for example to update your REC, you must select the right elements defining your RECs not the elements instanting your REC via RPLs.

Thanks for the response! A library is indeed a good solution for what I need

Copyright © Eclipse Capella, the Eclipse Capella logo, Eclipse and the Eclipse logo are Trademarks of The Eclipse Foundation.