Skip to content

Mapping Configuration


The Mapping Configuration is used to define which attributes from codebeamer work items are mapped to attributes from Enterprise Architect elements (and also vice versa).

The configuration is maintained via it's own dialog, which can be accessed via the addin menu point "Configure Mapping for Package". It is also automatically invoked when starting an import/export for a package which does not yet have a fully configured mapping.

Here is an explanation of the different section in the mapping user interface:

UI Section Title
codebeamer UI Section Reference to EA
The package in EA, which is associated with the tracker in codebeamer.
The associated package is always the one the mapping configuration UI has been started from, and cannot be changed later on.
codebeamer Project Reference to codebeamer
The codebeamer Project and Tracker.
You can type in the name of the tracker / project you are searching for, which will reduce the list of available elements.
Searching for Projects and Trackers
If you want to find a specific codebeamer project or tracker quickly, just click into the combo box and start typing the name.
A filter will be applied and the list will offer all matching projects or trackers:
import from codebeamer Mapping Settings
Either import from codebeamer to EA, or export from EA to codebeamer.
If you select "Export to codebeamer" you can additionally choose to export diagrams to codebeamer. 
Mapping Template
A mapping template provides examples mappings that can be loaded. Loading a template will reset the type and attribute mappins. LemonTree.Connect will not save which template was loaded for which package. You can only load the type and attribute mappings from the provided templates.

Please note that the configuration is only loaded after the "Load" button on the right is clicked. Also, doing so will erase any customizations you have made to your current configuration!

By default, templates will be loaded from the paths:
C:\Program Files (x86)\LieberLieber\codebeamerEAAddin\mapping\Export
C:\Program Files (x86)\LieberLieber\codebeamerEAAddin\mapping\Import
To customize templates and load them from an additional location, check out the guide "Create custom mapping templates".
EA Connector for Trace Link
LemonTree.Connect type that is used for exporting the traceability between architecture and requirements. 
codebeamer Field for Trace Link
The reference field in codebeamer that is corresponding to the trace link coming from EA.
Folder Package Type Mappings
A list of which codebeamer tracker item types are mapped to which EA element types (optionally with stereotypes).
For a detailed explanation, see the chapter "Type Mapping".
Attribute Mappings Attribute Mappings
A list of which codebeamer fields mapped to which EA element attributes. The attributes in EA can be either element properties or tagged values.
For a detailed explanation, see the chapter "Attribute Mapping".

The Trace Link Configuration determines how traceability links are realized in Enterprise Architect. The provided selection is between various types of connectors provided by Enterprise Architect, and has implications for both the import and the export of functionalities:

  • On Import, traceability links in the Enterprise Architect model are realized as connectors of the selected type between the imported elements
  • On Export, traceability links in codebeamer are established based on connectors of the selected type in the Enterprise Architect model

LemonTree.Connect currently supports the following trace link types:

  • Traces
    • EA Trace (15.1 and lower)
      EA versions 15.1 and lower used an UML "Abstraction" for trace links.
    • EA Trace (15.2 and lower)
      All EA versions higher than 15.1 use an UML "Dependency" for trace links.
  • SysML Links
    • SysML Copy
    • SysML Derive
    • SysML Refine
    • SysML Satisfy
    • SysML Trace
    • SysML Verify
  • Standard UML Links
    • UML Dependency
    • UML Realization

EA Trace Types

If you use a "trace" connector to establish the traceability, keep in mind that it depends on the EA version where you created the trace connector. If you created LemonTree.Connect with EA 15.1 and lower, but use a more recent version like 15.2, you still need to use the trace link type "EA Trace (15.1 and lower)".
If you want to use the newer link type, you have to recreate LemonTree.Connect or change its type to "Dependency" in EA.

If you want to use more than one link mappings you have to change the raw mapping configuration stored as XML in the configured package. Open the tagged value "config" of the configured package and add a mapping rule for each link mapping you want to use. Only the first one will be shown in the Mapping Configuration Dialog.

If you want to use trace and dependency links, your mapping could for example look like this:

  <!-- Trace -->
      <externalProperty name="_linkField" value="17" />
      <myumlProperty name="_objectType" value="Dependency" />
      <myumlProperty name="_stereotype" value="EAUML::trace" />
    <properties />
  <!-- Dependency -->
      <externalProperty name="_linkField" value="17" />
      <myumlProperty name="_objectType" value="Dependency" />
    <properties />

Type and Attribute Mappings

It is possible to create a mapping for a codebeamer tracker item type.

A mapping consists of the following entries:

  • Type Mapping
    Defines which codebeamer tracker item type is mapped to which EA element type

  • (one or many) Attribute Mappings
    Defines which attributes from a tracker item are mapped to which attributes from an EA element

If you select a Type Mapping in the configuration UI, the list of attributes will always show the attributes related to the selected Type Mapping:
Type Folder

Type Mapping

The type configuration establishes a list of one-to-one relations between a specific codebeamer element type and its UML equivalent in the Enterprise Architect model.


Keep in mind, that since EA 15 only stereotypes from a stereotype definition or an UML Profile / MDG Technology can be used. It is not possible to enter a "free-text" stereotype.

To use a stereotype properly, find the full qualified name of the stereotype in EA properties of that element:

The value of the stereotype property has to be used for a type mapping with a stereotype.

With the release 2.3.1 of the LemonTree.Connect, SysML Stereotypes are supported by default and are available as special EA element types. When using SysML, it is not necessary to add the full qualified stereotype.

Supported EA Element Types

Here is a list of the current supported EA Element Types:

  • AcceptEventAction
  • ActionInputPin
  • Activity
  • ActivityParameterNode
  • Actor
  • Artifact
  • CallBehaviorAction
  • CallOperationAction
  • Component
  • Class
  • DataType
  • Device
  • DeploymentSpecification
  • ExecutionEnvironment
  • Enumeration
  • InstanceSpecification
  • Interaction
  • Interface
  • Node
  • OpaqueAction
  • Operation
  • Package
  • Property
  • Port
  • Requirement
  • SendSignalAction
  • Signal
  • State
  • StateMachine
  • SysML Block
  • SysML Constraint Block
  • SysML Full Port
  • SysML Interface Block
  • SysML Proxy Port
  • SysML Requirement
  • SysML Test Case
  • Trigger
  • UseCase

Differences between EA and UML Element Types

Since our technology is based on UML, we also use the UML names of the element types. However, EA uses a different name for some of the offered element types.
To see which types are not called the same in the Mapping UI as in EA, check the table listed below:

EA Element Type Type in the Mapping UI
ActionPin ActionInputPin
Action (atomic) OpaqueAction
ActivityParameter ActivityParameterNode
Attribute Property
Object InstanceSpecification
Part Property

SysML Element Types

With the release of the version 2.3.1, SysML Types are now supported in a much more convient way. To use SysML element types, all you have to do is to select them from the list of types:
SysML Block


In order to use "Block Properties" (internal Parts of Blocks), you have to use the EA Type "Property".

Generic Type Mapping "TrackerItem"

The first entry in the list of available codebeamer types is called "TrackerItem".
This type is used as a generic type mapping, which applies to every item found in the codebeamer tracker.

However, if you also define a type mapping, which refers to a codebeamer type stored in the field "Categories", all elements with the corresponding type will be taken into account.

For example:
A tracker consists of five tracker items:

  • Item 1: Category = "–"
  • Item 2: Category = "Functional"
  • Item 3: Category = "Non-Functional"
  • Item 4: Category = Folder
  • Item 5: Category = Folder

The type mapping is defined as follows:

codebeamer Type EA Type
Folder Package
TrackerItem Requirement

This mapping will create EA Packages for the items "Item4" and "Item5". Every other element, no matter the type, will be created as EA Requirement.


Generic Type Mapping at the end

In order to define a "fallback type mapping", you have to add the generic type mapping "TrackerItem" at the end.
If the generic type mapping is added at the beginning, it will overwrite every other mapping and will be used as default.

Filter out unwanted tracker item types

It is possible to only import a specific set of tracker item types. You can do that by not configuring a "generic tracker item mapping", as it is described above.

For example:
A tracker consists of five tracker items:

  • Item 1: Category = "–"
  • Item 2: Category = "Functional"
  • Item 3: Category = "Non-Functional"
  • Item 4: Category = Info
  • Item 5: Category = Info

The type mapping is defined as follows:

|codebeamer Type|EA Type| Functional|Requirement Non-Functional|Requirement

This mapping will only import the tracker items "Item2" and "Item3", since there is no default type mapping, that considers tracker items with other types.

Special Case "Requirement"

The basis for LemonTree.Connect and the mapping to EA element is UML. Since Requirement elements are not standard UML but EA is providing them, a special mapping entry has to be introduced.

Attribute Mapping

The attribute mapping defines which attributes from a codebeamer element are mapped to which attributes of an EA element (and vice versa).


The attributes available for mapping are partially dependent on the selected tracker, as the tracker might offer custom attributes.

Currently, the following attributes are supported:

  • (Tagged Value) (custom attributes that are created as tagged values)
  • Alias
  • Author
  • Classifier (the instance classifier, property type, port type, etc. of an element)
  • Complexity
  • Created Date
  • Lower Bound (LowerBound of the Multiplicity for some element types )
  • Modified Date
  • Multiplicity (some element types use a different Multiplicity attribute)
  • Notes
  • Phase
  • Primitive Type (simple types that can be select in EA such as int, bool, long, etc.)
  • Status 1
  • Stereotype
  • Upper Bound (UpperBound of the Multiplicity for some elements)
  • Version

Use Tagged Values for Attribute Mappings

In order to use a tagged value for an attribute mapping, simply select the (Tagged Value) entry from the list of available EA Attributes. This will enable a textbox, where you can enter the name of the tagged value that shall be considered in the mapping:
Tagged Valuee

Mapping the Classifier of exported elements

If the classifier of an element is used in an export mapping, a special field configuration is needed in codebeamer to properly display the classifier field.

In codebeamer, you have to create two custom fields for the classifier, one (hidden) field to hold the raw data (name + id of the referenced element) and one to display the proper name of the classifier element.
To configure these two fields, check the guide "Displaying the Classifier of an exported element in codebeamer with a calculated field".

In EA, you have to map classifier on an element to the internal classifier field, for example:

new Attribute

Mandatory Attribute Mapping for the "Open in codebeamer" Feature

It is possible to open a tracker item directly in codebeamer, by either double clicking the representative element in EA, or selecting the menu Specialize > LemonTree.Connect codebeamer > Open in codebeamer.

To enable this feature, an attribute mapping for the codebeamer field "Uri" has to be created. If you create a custom mapping, LemonTree.Connect will automatically create this mapping entry for you.
Every new attribute mapping that will be created, consists of the following mappings:

  • Summary → Name
  • Description → Notes
  • Uri → Uri (Tagged Value)


If you remove the Uri mapping, the "Open in codebeamer" feature will be disabled.

Using the "Status" property of Requirements in EA

In order to save and visualize the status property of requirements in EA properly, the attribute mapping has to be done in a specific way. 

If you want the importer to write the status of the codebeamer item into the EA status property, you have to create an attribute mapping that looks like this:
Edit Attribute

Choose "(Tagged Value) for the EA Attribute and insert the following string into the "Tagged Value" textbox:

EA Specifics 1.0::requirement::Status

However, we recommend not using the status property from EA or Polarion for attribute mappings. In both tools, the status properties have predefined values, which should be set directly in the tool, with the allowed values and they might be related to specific workflows and / or state transitions.

  1. If you use an element of type Requirement in the mapping (a Class with the Stereotype "EA Specifics 1.0::requirement"), you have to use the attribute name "EA Specifics 1.0::requirement::Status". See Using the "Status" property of Requirements in EA for more details.