Variant Control Modes in Variant Blocks

The components of a Simulink^® model that contain variants are activated or deactivated based on the variant choice that you select.

Each variant choice in your model is associated with a variant control. Variant controls determine which variant choice is active. By changing the value of a variant control, you can switch the active variant choice. While each variant choice is associated with a variant control, only one variant control can evaluate to true. When a variant control evaluates to true, Simulink activates the variant choice that corresponds to that variant control. For a simple example, see Introduction to Variant Controls.

Types of Variant Control Modes in Variant Blocks

These are types of variant control modes in Simulink:

expression — The software chooses the active variant based on the evaluation of the variant conditions. When a condition expression evaluates to true, the corresponding variant choice becomes active. When a condition expression evaluates to false, the corresponding variant choice becomes inactive. See Switch Between Choices Using Condition Expressions in Variant Blocks.
label — The software chooses the active variant based on the name of the variant. The variant control is a string and does not require you to create any variable in any workspaces. See Switch Between Choices Using Labels in Variant Blocks.
sim codegen switching — Automatically switch between the variants for simulation and code generation workflows without creating any workspace variable. When you simulate a model, the software automatically chooses the sim branch as the active choice. Similarly, when you do a software-in-the-loop (SIL) or processor-In-Loop (PIL) simulation, generate code, or use external mode, the software automatically chooses the codegen branch. See Switch Between Choices for Simulation and Code Generation Workflows Without Using Control Variables in Variant Blocks.

Types of variant control modes with examples. In expression mode, variant control can be a boolean condition expression, a Simulink.VariantExpression object, or a default variant choice. In label mode, variant control is a string, and in sim codegen switching mode, variant controls are (sim) and (codegen) keywords.

Switch Between Choices Using Condition Expressions in Variant Blocks

In expression mode, Simulink chooses the active variant based on the evaluation of the variant conditions. When a condition expression evaluates to true, the corresponding variant choice becomes active. When a condition expression evaluates to false, the corresponding variant choice becomes inactive.

You can use the expression type of variant controls in variant blocks and in variant parameters.

Note

You can simulate and generate code from the model containing a variant block with Variant control mode set to expression mode. The generated code can contain active and inactive choices that are enclosed in preprocessor conditionals #if and #elif, or regular if conditions.

Use `expression` Type of Variant Control in Variant Blocks

To specify the variant condition expressions in variant blocks:

Right-click the badge on the variant block, select Block Parameters, and then specify the variant condition expression in the Variant control expression parameter of the block parameter dialog box.
Variant control mode: expression
Use this command.
```
set_param('Model/Controller/Linear Controller',...
 'VariantControl', 'VSS_MODE == 1')
```
In this command, Model/Controller/Linear Controller is the full path of the variant choice, and VSS_MODE == 1 is the expression associated with the variant choice in the model Model.

Types of Variant Controls in `expression` Mode

The variant controls can be:

Boolean condition expression for rapid prototyping. For example, A == 1, A ~= B, A && B == 1, and so on.
A Simulink.VariantExpression object that contains condition expressions for condition reuse. See Simulink.VariantExpression Objects for Variant Condition Reuse of Variant Blocks.
A default variant control if none of the choices evaluates to true. You can specify at most one variant choice as the default for the block. During simulation, if none of the variant controls evaluate to true, Simulink uses the default variant as the active variant choice. To set a variant choice as the default, select the (default) keyword in the Variant control expression column for that choice.

Here, A and B are operands called as variant control variables. +, ==, and && are operators in the condition expression. The condition expression can contain one or more such variant control variables and operators. For information on supported types and storage location of variant control variables, see Types of Variant Control Variables (Operands) in Variant Blocks and Storage Locations for Variant Control Variables (Operands) in Variant Blocks. For information on operators, see Types of Operators in Variant Blocks for Different Activation Times.

Note

You can comment out the variant controls by placing a % symbol before the control expressions. During simulation, if the corresponding variant choice is active, Simulink ignores the variant choice. However, Simulink continues to execute block callbacks inside the variant choice.

Types of Variant Control Variables (Operands) in Variant Blocks

In expression mode, you can specify the variant control variables as any of these types, from options to use while prototyping to options required for generating code from your model.

Specification	Purpose	Example
`Simulink.VariantControl`	Associate a variant activation time to switch choices coherently	`A == 1`, where `A` is a `Simulink.VariantControl` object. See Simulink.VariantControl Variables for Coherent Switching of Choices in Variant Blocks.
Scalar variable	Rapid prototyping	`A == 1`, where `A` is a scalar variable. See Scalar Variant Control Variables for Rapid Prototyping in Variant Blocks.
`Simulink.Parameter` object	Generate preprocessor conditionals for code generation	`Vssmode == 1`, where `Vssmode` is a `Simulink.Parameter` object. See Simulink.Parameter Type of Variant Control Variables for Code Generation in Variant Blocks.
Simulink Enumerations	Improved code readability because condition values are represented as meaningful names instead of integers	`LEVEL == Level.Advanced`, where `Level` is an integer-based enumeration class and `Advanced` is the enumerated value. See Enumerated Types To Improve Code Readability of Variant Control Variables of Variant Blocks.
`Simulink.Variant` object	Reuse variant conditions	`LinearController == 1`, where `LinearController` is a `Simulink.VariantExpression` object that encapsulates the condition expression `FUEL==2 && EMIS==1`. See Simulink.VariantExpression Objects for Variant Condition Reuse of Variant Blocks. Note A Variant Assembly Subsystem block does not support `Simulink.VariantExpression` type of variant control variable.
`struct`	Group related variant control variables	`Controller.Linear == 1`, where `Controller` is a `struct` and `Linear` is its field. See Structures to Group Related Variant Control Variables of Variant Blocks.

For list of all examples, see Use Variant Control Variables in Variant Blocks.

Storage Locations for Variant Control Variables (Operands) in Variant Blocks

You can define the variant control variables in different storage locations based on your requirement. When you define a variable across the base, mask, and model workspaces, the evaluation order begins with the mask workspace, followed by the model workspace, and then the base workspace. This means that the variable's definition in the closest context is prioritized, ensuring that the most relevant value is used for evaluating the variant condition expressions.

Note

All the variant control variables in a variant block must originate from the same storage location.
Use Simulink.SimulationInput in the base, mask, and model workspace when the Variant activation time parameter is set to startup.
Define variant control variables for the Initialize Function, Reset Function, Reinitialize Function, and Terminate Function blocks in the following workspaces when the Generate preprocessor conditionals parameter is set to off. However, if the parameter is on, you must define these variables in the base workspace or within a data dictionary, as these are the only allowed storage locations.

Storage Location	Use for Storage Location	Supported Types of Variant Control Variables (See Types of Variant Control Variables (Operands) in Variant Blocks)	For More Information
Base workspace	Store variables while you experiment with temporary models	Scalar variables, `Simulink.VariantExpression`, `Simulink.Parameter`, enumerated type, `Simulink.VariantControl`, and `struct`	Temporary Data: Base Workspace
Mask workspace	Permanently store data that is local to the mask of a block.	Scalar variables, enumerated type, and `Simulink.VariantControl`	Approaches to Control Active Variant Choice of a Variant Block Using Mask or Model Workspace
Model workspace	Permanently store data that is local to a model	Scalar variables, enumerated type, and `Simulink.VariantControl`	Approaches to Control Active Variant Choice of a Variant Block Using Mask or Model Workspace
Data dictionary	Permanently store global data, share data between models, and track changes made to data.	Scalar variables, `Simulink.VariantExpression`, `Simulink.Parameter`, enumerated type, `Simulink.VariantControl`, and `struct`	What Is a Data Dictionary?

For capabilities and advantages of each storage location, see Determine Where to Store Variables and Objects for Simulink Models

Types of Operators in Variant Blocks for Different Activation Times

Variant condition expressions can contain MATLAB^® operators, provided the expression evaluates to a Boolean value.

In variant blocks, the operators that you can use to form a variant condition expression depends on the Variant activation time.

When you specify the Variant activation time as:

update diagram — Any condition expression that evaluates to true or false.

update diagram analyze all choices or code compile — The supported operators are:

Parentheses for grouping

Arithmetic Operators, Relational Operators, Logical Operators, and Bit-Wise Operations, as listed in this table.

This table lists the MATLAB operators and their representation in the generated code. In these examples, A and B are expressions that evaluate to an integer, and x is a constant integer literal.

MATLAB Expressions That Support Generation of Preprocessor Conditionals	Equivalent Expression in C Preprocessor Conditional of Generated Code
Arithmetic
`A + B` `+A`	`A + B` `A`
`A - B` `-A`	`A - B` `-A`
`A * B`	`A * B`
`idivide(A,B)`	`A / B` If the value of the second operand (`B`) is `0`, the behavior is undefined.
`rem(A,B)`	`A % B` If the value of the second operand (`B`) is `0`, the behavior is undefined.
Relational
`A == B`	`A == B`
`A ~= B`	`A != B`
`A < B`	`A < B`
`A > B`	`A > B`
`A <= B`	`A <= B`
`A >= B`	`A >= B`
Logical
`~A`	`!A`, where `A` is not an integer
`A && B`	`A && B`
`A \|\| B`	`A \|\| B`
Bitwise (`A` and `B` cannot both be constant integer literals)
`bitand(A,B)`	`A & B`
`bitor(A,B)`	`A \| B`
`bitxor(A,B)`	`A ^ B`
`bitcmp(A)`	`~A`
`bitshift(A,x)`	`A << x`
`bitshift(A,-x)`	`A >> x`

startup — The supported operators are:

Parentheses for grouping

Relational Operators and Logical Operators, as listed in this table.

This table lists the MATLAB operators and their representation in the generated code. In these examples, A and B are expressions that evaluate to an integer.

Supported Operators in Variant Condition Expression	Equivalent Expression in Regular `if` of Generated Code
Relational
`A == B`	`A == B`
`A ~= B`	`A != B`
Logical
`~A`	`!A`, where `A` is not an integer
`A && B`	`A && B`
`A \|\| B`	`A \|\| B`

Note

In variant blocks with startup activation time:

For the variant control variables with any activation time, the variant control variables that originate from the mask or the model workspace cannot be used in the MATLAB in-built functions such as idivide, bitand, and so on to form expressions.
AUTOSAR post-build variants support only == and && operators. For more information, see Configure Postbuild Variant Conditions for AUTOSAR Software Components (AUTOSAR Blockset).

Evaluate Variant Condition Expressions at Different Variant Activation Times

In expression mode, you can specify if Simulink must evaluate condition expressions during model compile, simulation-loop, code compile, or model start up stage of simulation and code generation workflow using variant activation times. For information on stages of simulation and code generation and supported variant activation times in expression mode, see Activate Variant During Different Stages of Simulation and Code Generation Workflow.

Automatically Identify Variant Regions Using Variant Condition Propagation

Simulink determines the model components that are active during simulation by the process of variant condition propagation. This process evaluates the variant controls specified on the variant blocks and automatically propagates the variant conditions to the connecting blocks. Variant conditions can propagate through signal lines, buses, and function calls to reach other blocks in the model. The process deactivates the model components associated with the inactive choices and they do not participate in simulation. You can stop condition propagation to define variant regions in the model.

You can limit variant condition propagation in a bounded region using the Variant Start and Variant End blocks. For more information on bounded region, see Variant Start.

You can use the Variant Conditions Legend to visualize the propagated variant conditions that activate each variant choice. Simulink annotates model components if there are variant conditions on them, and the Variant Conditions Legend displays the condition that corresponds to each annotation.

For more information, see Propagate Variant Conditions to Define Variant Regions with Variant Blocks.

Switch Between Choices Using Labels in Variant Blocks

In label mode, Simulink chooses the active variant based on the name of the variant. The variant control is a string and does not require you to create variable in any workspaces.

Note

In label mode, the activation time of the variant block is set to update diagram by default. In other words, when you simulate a model or generate code from a model, Simulink determines the active choice in the model compilation stage and generates code only for the active choice. See Activate Variant During Different Stages of Simulation and Code Generation Workflow.

Use `label` Mode in Variant Blocks

To specify the labels for choices in variant blocks, right-click the badge on the variant block, select Block Parameters, and then specify the labels in the Variant control label parameter of the block parameter dialog box.

Variant control mode: label

Set Active Choices Using Variant Control Labels

You can follow any of these approaches to set active choices in label mode:

Specify a name for each variant choice in the Variant control label parameter of the variant block dialog box. All the names that you specify are listed in the Label mode active choice drop-down. The label that you select from the list becomes the active choice.
Right-click the badge on the variant block and select Label Mode Active Choice.
From the mask workspace using the initialization code. Using the mask initialization code, you can specify the active choice from variant block or any subsystem in the hierarchy. The active choice you specify in the mask initialization code overrides the active choice you specify using the Label mode active choice drop-down or the Label Mode Active Choice menu item. For more information, see Mask a Variant Subsystem.
Use this command:
```
set_param(blockName,'LabelModeActiveChoice', 'variantChoiceLabel')
```
where blockName is the name of the variant block and variantChoiceLabel is the label associated with the variant choice.

Switch Between Choices for Simulation and Code Generation Workflows Without Using Control Variables in Variant Blocks

To automatically switch between the choices for simulation and code generation workflows without creating any workspace variable, use the sim codegen switching variant control mode.

Note

In sim codegen switching mode, only the update diagram and the update diagram analyze all choices activation times are supported. In other words, when you simulate or generate code from a model, Simulink determines the active choice in the model compilation stage and generates the code only for the choice. See, Activate Variant During Different Stages of Simulation and Code Generation Workflow.

Use `sim codegen switching` Mode in Variant Blocks

To specify simulation and code generation branches for variant choices, right-click the badge on the variant block, select Block Parameters, and then specify the (sim) and (codegen) keywords in the Variant control switch parameter of the block parameter dialog box.

When you simulate a model in normal, accelerator, or rapid Accelerator mode, Simulink automatically chooses the (sim) branch as the active choice. Similarly, when you do a software-in-the-loop (SIL), processor-In-Loop (PIL) simulation or generate code or use external mode, Simulink automatically chooses the (codegen) branch. The code is generated only for the active choice. Inactive choices are not included in the generated code. In this mode, you can at most have only two choices in the variant block.

Variant control mode: sim codegen switching

Compare Different Types of Variant Control Modes in Variant Blocks

This table explains the capabilities of different variant control modes to help you choose one that caters to your requirement.

Variant control mode Capabilities

Variant control mode	Capabilities
`expression` — Simulink chooses the active variant based on the evaluation of the variant conditions. When a condition expression evaluates to `true`, the corresponding variant choice becomes active. When a condition expression evaluates to `false`, the corresponding variant choice becomes inactive.	Use `expression` mode to: Control the active choice from different sources such as base, mask, model workspace, and data dictionary. Each source defines a scope of visibility, which allows you to efficiently set different active choices for blocks in different scope. For more information, see Storage Locations for Variant Control Variables (Operands) in Variant Blocks. Set different active choices for multiple instances of a variant block that belongs to a custom locked library. For more information, see Control Active Choice of Locked Custom Library Variant Subsystem Using Mask Parameter. Propagate the state of the underlying blocks outside of Variant Subsystem to improve the accuracy of the model and to simplify model construction. You are not required to manually compute the variant conditions assigned to the dependent or connected blocks. For more information, see Propagate conditions outside of variant subsystem. Use `code compile` activation time to: Generate a code that contains active and inactive choices of the model in C preprocessor conditionals `#if` and `#elif`. The preprocessor conditionals are conditionally compiled for the active choice that you provide as an input to the compiler. For more information, see Compile Code Conditionally for Variations of Component Represented Using Variant Block (Embedded Coder). Generate conditionally compiling code for AUTOSAR targets. Identify incorrect model constructs, detect design errors, and generate test cases for model coverage of active variants. For more information, see Verify and Validate Variant Models with Code Compile Activation Time. Use `startup` activation time to: Improve the speed of iterative simulations and Simulink Test workflows using fast restart. For more information, see Run Iterative Simulations Without Recompiling Model for Variant Systems Using Fast Restart. Simulate multiple configurations in parallel with different active choices in each run. For more information, see Simulate Variant Subsystem with Startup Activation Using parsim. Identify incorrect model constructs, detect design errors, and generate test cases for model coverage of active and inactive variants. For more information, see Verify and Validate Variant Models with Startup Activation Time. Generate a code that contains active and inactive choices of the model in regular `if` conditions. The `if` condition is evaluated and conditionally executed for the active choice that you provide as an input to the executable. For more information, see Run Executables for Variant Blocks Without Recompiling Code for Changing Active Choices Using Startup Activation Time (Simulink Coder). For AUTOSAR variants, include post-build variation points in ARXML files. For more information, see Configure Postbuild Variant Conditions for AUTOSAR Software Components (AUTOSAR Blockset).
`label` — Simulink chooses the active variant based on the name of the variant. The variant control is a string and does not require you to create variable in any workspace.	Use `label` mode to: Control active choices without creating any workspace variables. Generate code only for active choice in the model.
`sim codegen switching` — When you simulate a model in normal, accelerator, or rapid Accelerator mode, then Simulink automatically chooses the `sim` branch as the active choice. Similarly, when you do a software-in-the-loop (SIL), processor-In-Loop (PIL) simulation or generate code or use external mode, Simulink automatically chooses the `codegen` branch.	Use `sim codegen switching` switching mode to: To automatically switch between the choices for simulation and code generation workflows without creating any workspace variables. Generate code only for active choice in the model.

expression — Simulink chooses the active variant based on the evaluation of the variant conditions. When a condition expression evaluates to true, the corresponding variant choice becomes active. When a condition expression evaluates to false, the corresponding variant choice becomes inactive.

Use expression mode to:

Control the active choice from different sources such as base, mask, model workspace, and data dictionary. Each source defines a scope of visibility, which allows you to efficiently set different active choices for blocks in different scope. For more information, see Storage Locations for Variant Control Variables (Operands) in Variant Blocks.
Set different active choices for multiple instances of a variant block that belongs to a custom locked library. For more information, see Control Active Choice of Locked Custom Library Variant Subsystem Using Mask Parameter.
Propagate the state of the underlying blocks outside of Variant Subsystem to improve the accuracy of the model and to simplify model construction. You are not required to manually compute the variant conditions assigned to the dependent or connected blocks. For more information, see Propagate conditions outside of variant subsystem.
Use code compile activation time to:
- Generate a code that contains active and inactive choices of the model in C preprocessor conditionals #if and #elif. The preprocessor conditionals are conditionally compiled for the active choice that you provide as an input to the compiler. For more information, see Compile Code Conditionally for Variations of Component Represented Using Variant Block (Embedded Coder).
- Generate conditionally compiling code for AUTOSAR targets.
- Identify incorrect model constructs, detect design errors, and generate test cases for model coverage of active variants. For more information, see Verify and Validate Variant Models with Code Compile Activation Time.
Use startup activation time to:
- Improve the speed of iterative simulations and Simulink Test workflows using fast restart. For more information, see Run Iterative Simulations Without Recompiling Model for Variant Systems Using Fast Restart.
- Simulate multiple configurations in parallel with different active choices in each run. For more information, see Simulate Variant Subsystem with Startup Activation Using parsim.
- Identify incorrect model constructs, detect design errors, and generate test cases for model coverage of active and inactive variants. For more information, see Verify and Validate Variant Models with Startup Activation Time.
- Generate a code that contains active and inactive choices of the model in regular if conditions. The if condition is evaluated and conditionally executed for the active choice that you provide as an input to the executable. For more information, see Run Executables for Variant Blocks Without Recompiling Code for Changing Active Choices Using Startup Activation Time (Simulink Coder).
- For AUTOSAR variants, include post-build variation points in ARXML files. For more information, see Configure Postbuild Variant Conditions for AUTOSAR Software Components (AUTOSAR Blockset).

label — Simulink chooses the active variant based on the name of the variant. The variant control is a string and does not require you to create variable in any workspace.

Use label mode to:

Control active choices without creating any workspace variables.
Generate code only for active choice in the model.

sim codegen switching — When you simulate a model in normal, accelerator, or rapid Accelerator mode, then Simulink automatically chooses the sim branch as the active choice. Similarly, when you do a software-in-the-loop (SIL), processor-In-Loop (PIL) simulation or generate code or use external mode, Simulink automatically chooses the codegen branch.

Use sim codegen switching switching mode to:

To automatically switch between the choices for simulation and code generation workflows without creating any workspace variables.
Generate code only for active choice in the model.

Variant Activation Times for Different Variant Control Modes in Variant Blocks

This table explains the variant activation time supported for different variant control modes in variant blocks. For information on variant activation times, see Activate Variant During Different Stages of Simulation and Code Generation Workflow.

Variant activation time
Variant blocks	Variant control mode	`update diagram`	`update diagram analyze all choices`	`code compile`	`startup`	`runtime`
Variant Subsystem	`expression`	✓	✓	✓	✓	✓
	`label`	✓	x	x	x	x
	`sim codegen switching`	✓	✓	x	x	x
Variant Model, Variant Source, Variant Sink	`expression`	✓	✓	✓	✓	not supported
	`label`	✓	x	x	x	not supported
	`sim codegen switching`	✓	✓	x	x	not supported
Variant Connector (Simscape), Manual Variant Source, Manual Variant Sink	`expression`	✓	x	x	x	not supported
	`label`	not supported				not supported
	`sim codegen switching`	not supported				not supported
Simulink Function, Initialize Function, Reset Function, and Terminate Function	`expression`	✓	✓	✓	x	not supported
	`label`	not supported				not supported
	`sim codegen switching`	not supported				not supported

Related Examples

More About

Introduction to Variant Controls