Main Content

setDefaultElementStereotype

Set default stereotype for elements

Since R2021b

collapse all in page

Syntax

setDefaultElementStereotype(stereotype,elementType,stereotypeName)

Description

example

setDefaultElementStereotype(stereotype,elementType,stereotypeName) specifies the default stereotype stereotypeName of the child elements whose parent element of type elementType has the stereotype stereotype applied.

Examples

collapse all

Create a profile for latency characteristics and save it.

profile = systemcomposer.profile.Profile.createProfile("LatencyProfile");

latencybase = profile.addStereotype("LatencyBase");
latencybase.addProperty("latency",Type="double");
latencybase.addProperty("dataRate",Type="double",DefaultValue="10");

connLatency = profile.addStereotype("ConnectorLatency",...
Parent="LatencyProfile.LatencyBase");
connLatency.addProperty("secure",Type="boolean");
connLatency.addProperty("linkDistance",Type="double");

nodeLatency = profile.addStereotype("NodeLatency",...
Parent="LatencyProfile.LatencyBase");
nodeLatency.addProperty("resources",Type="double",DefaultValue="1");

portLatency = profile.addStereotype("PortLatency",...
Parent="LatencyProfile.LatencyBase");
portLatency.addProperty("queueDepth",Type="double");
portLatency.addProperty("dummy",Type="int32");

profile.save

Specify the LatencyProfile.NodeLatency stereotype as a component stereotype. Set the default component stereotype.

nodeLatency.AppliesTo = "Component";
nodeLatency.setDefaultElementStereotype("Component","LatencyProfile.NodeLatency")

Create a model, apply the profile to the model, and add a parent component. Apply the parent component stereotype on the parent component. Then, open the Profile Editor.

modelName = "archModel";
arch = systemcomposer.createModel(modelName,true);
arch.applyProfile("LatencyProfile");
newComponent = addComponent(arch.Architecture,"Component");
newComponent.applyStereotype("LatencyProfile.NodeLatency");
systemcomposer.profile.editor(profile)

Create a child component and get the stereotypes on the child component.

childComponent = addComponent(newComponent.Architecture,"Child");
stereotypes = getStereotypes(childComponent)
stereotypes =

  1×1 cell array

    {'LatencyProfile.NodeLatency'}

Create a profile for latency characteristics and save it.

profile = systemcomposer.profile.Profile.createProfile("LatencyProfile");

latencybase = profile.addStereotype("LatencyBase");
latencybase.addProperty("latency",Type="double");
latencybase.addProperty("dataRate",Type="double",DefaultValue="10");

connLatency = profile.addStereotype("ConnectorLatency",...
Parent="LatencyProfile.LatencyBase");
connLatency.addProperty("secure",Type="boolean");
connLatency.addProperty("linkDistance",Type="double");

nodeLatency = profile.addStereotype("NodeLatency",...
Parent="LatencyProfile.LatencyBase");
nodeLatency.addProperty("resources",Type="double",DefaultValue="1");

portLatency = profile.addStereotype("PortLatency",...
Parent="LatencyProfile.LatencyBase");
portLatency.addProperty("queueDepth",Type="double");
portLatency.addProperty("dummy",Type="int32");

profile.save

Specify the LatencyProfile.NodeLatency stereotype as a component stereotype. Set the default port stereotype.

nodeLatency.AppliesTo = "Component";
nodeLatency.setDefaultElementStereotype("Port","LatencyProfile.PortLatency");

Create a model, apply the profile to the model, and add a parent component. Apply the parent component stereotype on the parent component. Then, open the Profile Editor.

modelName = "archModel";
arch = systemcomposer.createModel(modelName,true);
arch.applyProfile("LatencyProfile");
newComponent = addComponent(arch.Architecture,"Component");
newComponent.applyStereotype("LatencyProfile.NodeLatency");
systemcomposer.profile.editor(profile)

Create an architecture port on the component and get the stereotypes on the port.

port = addPort(newComponent.Architecture,"testSig","out"); 
stereotypes = getStereotypes(port)
stereotypes =

  1×1 cell array

    {'LatencyProfile.PortLatency'}

Create a profile for latency characteristics and save it.

profile = systemcomposer.profile.Profile.createProfile("LatencyProfile");

latencybase = profile.addStereotype("LatencyBase");
latencybase.addProperty("latency",Type="double");
latencybase.addProperty("dataRate",Type="double",DefaultValue="10");

connLatency = profile.addStereotype("ConnectorLatency",...
Parent="LatencyProfile.LatencyBase");
connLatency.addProperty("secure",Type="boolean");
connLatency.addProperty("linkDistance",Type="double");

nodeLatency = profile.addStereotype("NodeLatency",...
Parent="LatencyProfile.LatencyBase");
nodeLatency.addProperty("resources",Type="double",DefaultValue="1");

portLatency = profile.addStereotype("PortLatency",...
Parent="LatencyProfile.LatencyBase");
portLatency.addProperty("queueDepth",Type="double");
portLatency.addProperty("dummy",Type="int32");

profile.save

Specify the LatencyProfile.NodeLatency stereotype as a component stereotype. Set the default connector stereotype.

nodeLatency.AppliesTo = "Component";
nodeLatency.setDefaultElementStereotype("Connector","LatencyProfile.ConnectorLatency");

Create a model, apply the profile to the model, and add a parent component. Apply the parent component stereotype on the parent component. Then, open the Profile Editor.

modelName = "archModel";
arch = systemcomposer.createModel(modelName,true);
arch.applyProfile("LatencyProfile");
newComponent = addComponent(arch.Architecture,"Component");
newComponent.applyStereotype("LatencyProfile.NodeLatency");
systemcomposer.profile.editor(profile)

Create two child components. Add ports. Then, create a connection between the ports and get stereotypes on the connector.

childComponent1 = addComponent(newComponent.Architecture,"Child1");
childComponent2 = addComponent(newComponent.Architecture,"Child2");

outPort1 = addPort(childComponent1.Architecture,"testSig","out"); 
inPort1 = addPort(childComponent2.Architecture,"testSig","in");
srcPort = getPort(childComponent1,"testSig");
destPort = getPort(childComponent2,"testSig");

connector = connect(srcPort,destPort);
stereotypes = getStereotypes(connector)
stereotypes =

  1×1 cell array

    {'LatencyProfile.ConnectorLatency'}

Input Arguments

collapse all

Stereotype, specified as a systemcomposer.profile.Stereotype object.

Element type, specified as "Component", "Port", "Connector", "Interface", or "Function". The element type "Function" is only available for software architectures.

Data Types: char | string

Default stereotype name for child elements, specified as a character vector or string in the form "<profile>.<stereotype>".

Data Types: char | string

More About

collapse all

Definitions

TermDefinitionApplicationMore Information
architecture

A System Composer™ architecture represents a system of components and how they interface with each other structurally and behaviorally.

Different types of architectures describe different aspects of systems. You can use views to visualize a subset of components in an architecture. You can define parameters on the architecture level using the Parameter Editor.
model

A System Composer model is the file that contains architectural information, including components, ports, connectors, interfaces, and behaviors.

Perform operations on a model:

  • Extract the root-level architecture contained in the model.

  • Apply profiles.

  • Link interface data dictionaries.

  • Generate instances from model architecture.

A System Composer model is stored as an SLX file.

Create Architecture Model with Interfaces and Requirement Links
component

A component is a nontrivial, nearly independent, and replaceable part of a system that fulfills a clear function in the context of an architecture. A component defines an architectural element, such as a function, a system, hardware, software, or other conceptual entity. A component can also be a subsystem or subfunction.

Represented as a block, a component is a part of an architecture model that can be separated into reusable artifacts. Transfer information between components with:

Components
port

A port is a node on a component or architecture that represents a point of interaction with its environment. A port permits the flow of information to and from other components or systems.

There are different types of ports:

  • Component ports are interaction points on the component to other components.

  • Architecture ports are ports on the boundary of the system, whether the boundary is within a component or the overall architecture model.

Ports
connector

Connectors are lines that provide connections between ports. Connectors describe how information flows between components or architectures.

A connector allows two components to interact without defining the nature of the interaction. Set an interface on a port to define how the components interact.

Connections

TermDefinitionApplicationMore Information
stereotype

A stereotype is a custom extension of the modeling language. Stereotypes provide a mechanism to extend the architecture language elements by adding domain-specific metadata.

Apply stereotypes to model elements such as root-level architecture, component architecture, connectors, ports, data interfaces, value types, functions, requirements, and links. Functions only apply to software architectures. You must have a Requirements Toolbox™ license to apply stereotypes to requirements and links. A model element can have multiple stereotypes. Stereotypes provide model elements with a common set of property fields, such as mass, cost, and power.

Extend Architectural Design Using Stereotypes
property

A property is a field in a stereotype. You can specify property values for each element to which the stereotype is applied.

Use properties to store quantitative characteristics, such as weight or speed, that are associated with a model element. Properties can also be descriptive or represent a status. You can view and edit the properties of each element in the architecture model using the Property Inspector.
profile

A profile is a package of stereotypes that you can use to create a self-consistent domain of element types.

Author profiles and apply profiles to a model using the Profile Editor. You can store stereotypes for a project in one or several profiles. When you save profiles, they are stored in XML files.

Version History

Introduced in R2021b

See Also

| |

Topics