find_system

Find systems, blocks, lines, ports, and annotations

collapse all in page

Syntax

Objects = find_system

Objects = find_system(System)

Objects = find_system(Name,Value)

Objects = find_system(System,Name,Value)

Description

example

Objects = find_system returns loaded systems and their blocks, including subsystems.

example

Objects = find_system(System) returns the specified system and its blocks.

example

Objects = find_system(Name,Value) returns loaded systems and the objects in those systems that meet the criteria specified by one or more Name,Value pair arguments. You can use this syntax to specify search constraints and to search for specific parameter values. Specify the search constraints before the parameter and value pairs.

example

Objects = find_system(System,Name,Value) returns the objects in the specified system that meet the specified criteria.

Examples

collapse all

Find Loaded Systems and Their Blocks

Open Live Script

Return the names of all loaded systems and their blocks.

load_system('vdp')
find_system

ans = 15x1 cell
    {'vdp'                     }
    {'vdp/Constant'            }
    {'vdp/More Info'           }
    {'vdp/More Info/Model Info'}
    {'vdp/Mu'                  }
    {'vdp/Mux'                 }
    {'vdp/Product'             }
    {'vdp/Scope'               }
    {'vdp/Square'              }
    {'vdp/Sum'                 }
    {'vdp/Sum1'                }
    {'vdp/x1'                  }
    {'vdp/x2'                  }
    {'vdp/Out1'                }
    {'vdp/Out2'                }

Returns loaded systems and libraries, including vdp.

Find Specific System and Its Blocks

Open Live Script

Return vdp system and its blocks.

load_system({'vdp','ex_sldemo_clutch'})
find_system('vdp')

ans = 15x1 cell
    {'vdp'                     }
    {'vdp/Constant'            }
    {'vdp/More Info'           }
    {'vdp/More Info/Model Info'}
    {'vdp/Mu'                  }
    {'vdp/Mux'                 }
    {'vdp/Product'             }
    {'vdp/Scope'               }
    {'vdp/Square'              }
    {'vdp/Sum'                 }
    {'vdp/Sum1'                }
    {'vdp/x1'                  }
    {'vdp/x2'                  }
    {'vdp/Out1'                }
    {'vdp/Out2'                }

Return Names of Loaded Models, Subsystems, and Libraries

Open Live Script

Return the names of the loaded models, subsystems, and libraries. A subsystem name is returned only if the subsystem can be loaded independently.

load_system('vdp');
find_system('type','block_diagram')

ans = 1x1 cell array
    {'vdp'}

Search Children of Subsystem

Open Live Script

Return the names of all Goto blocks that are children of the Unlocked subsystem in the ex_sldemo_clutch system.

load_system('ex_sldemo_clutch');
find_system('ex_sldemo_clutch/Unlocked','SearchDepth',1,'BlockType','Goto')

ans = 2x1 cell
    {'ex_sldemo_clutch/Unlocked/Goto' }
    {'ex_sldemo_clutch/Unlocked/Goto1'}

Search Using Multiple Criteria

Open Live Script

Search in the vdp system and return the names of all Gain blocks whose Gain value is set to 1.

load_system('vdp');
find_system('vdp','BlockType','Gain','Gain','1')

ans = 1x1 cell array
    {'vdp/Mu'}

Return Lines and Annotations as Handles

Open Live Script

Get the handles of all lines and annotations in the vdp system. With 'FindAll', the function returns handles regardless of how you specify the system to search.

load_system('vdp');
L = find_system('vdp','FindAll','on','type','line')

A = find_system('vdp','FindAll','on','type','annotation')

Search for Specific Block Parameter Value

Find any block dialog box parameters with a value of 0 in the vdp and ex_sldemo_clutch systems.

load_system({'vdp','f14'})
find_system({'vdp','f14'},'BlockDialogParams','0')

ans =

  32×1 cell array

    {'vdp/More Info'                                              }
    {'vdp/More Info/Model Info'                                   }
    {'vdp/Scope'                                                  }
    {'vdp/x2'                                                     }
    {'vdp/Out1'                                                   }
    {'vdp/Out1'                                                   }
    {'vdp/Out2'                                                   }
    {'vdp/Out2'                                                   }
    {'f14/Aircraft↵Dynamics↵Model'                              }
    {'f14/Aircraft↵Dynamics↵Model/Vertical Velocity↵w (ft//sec)'}
    {'f14/Aircraft↵Dynamics↵Model/Vertical Velocity↵w (ft//sec)'}
    {'f14/Aircraft↵Dynamics↵Model/Pitch Rate↵q (rad//sec)'      }
    {'f14/Aircraft↵Dynamics↵Model/Pitch Rate↵q (rad//sec)'      }
				.
				.
				.

Search Using Regular Expressions

Open Live Script

Find all blocks in the top level of the currently loaded systems with a block dialog parameter value that starts with 3.

load_system({'ex_sldemo_clutch','vdp'});
find_system('SearchDepth','1','regexp','on','BlockDialogParams','^3')

ans = 4x1 cell
    {'vdp/Scope'         }
    {'vdp/Scope'         }
    {'vdp/Square'        }
    {'ex_sldemo_clutch/w'}

Regular Expression Search for Partial Match

Open Live Script

When you search using regular expressions, you can specify a part of the character vector you want to match to return all objects that contain that character vector. Find all the inport and outport blocks in the ex_sldemo_clutch model.

load_system('ex_sldemo_clutch');
find_system('ex_sldemo_clutch','regexp','on','blocktype','port')

ans = 39x1 cell
    {'ex_sldemo_clutch/Friction...'                               }
    {'ex_sldemo_clutch/Friction...'                               }
    {'ex_sldemo_clutch/Friction...'                               }
    {'ex_sldemo_clutch/Friction Mode Logic/Tin'                   }
    {'ex_sldemo_clutch/Friction Mode Logic/Tfmaxs'                }
    {'ex_sldemo_clutch/Friction Mode Logic/Break Apart...'        }
    {'ex_sldemo_clutch/Friction Mode Logic/Break Apart...'        }
    {'ex_sldemo_clutch/Friction Mode Logic/Break Apart...'        }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup...'             }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup FSM/lock'       }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup FSM/unlock'     }
    {'ex_sldemo_clutch/Friction Mode Logic/Lockup FSM/locked'     }
    {'ex_sldemo_clutch/Friction Mode Logic/Requisite Friction/Tin'}
    {'ex_sldemo_clutch/Friction Mode Logic/Requisite Friction/Tf' }
    {'ex_sldemo_clutch/Friction Mode Logic/locked'                }
    {'ex_sldemo_clutch/Friction Mode Logic/lock'                  }
    {'ex_sldemo_clutch/Friction Mode Logic/unlock'                }
    {'ex_sldemo_clutch/Friction Mode Logic/Tf'                    }
    {'ex_sldemo_clutch/Locked/Tin'                                }
    {'ex_sldemo_clutch/Locked/w'                                  }
    {'ex_sldemo_clutch/Unlocked/Tfmaxk'                           }
    {'ex_sldemo_clutch/Unlocked/Tin'                              }
    {'ex_sldemo_clutch/Unlocked/we'                               }
      ⋮

Update Library Links in a Subsystem

In this example, myModel contains a single subsystem, which is a library link. After the model was last opened, a Gain block was added to the corresponding subsystem in the library.

Open the model. Use find_system with 'FollowLinks' set to 'off'. The command does not follow the library links into the subsystem and returns only the subsystem at the top level.

open_system('myModel')
find_system(bdroot,'LookUnderMasks','on','FollowLinks', 'off')

ans = 

    'myModel'
    'myModel/Subsystem'

Use find_system with 'FollowLinks' set to 'on'. find_system updates the library links and returns the block in the subsystem.

find_system(bdroot,'LookUnderMasks','on','FollowLinks','on')

Updating Link: myModel/Subsystem/Gain
Updating Link: myModel/Subsystem/Gain

ans = 

    'myModel'
    'myModel/Subsystem'
    'myModel/Subsystem/Gain'

Return Values as Handles

Open Live Script

Provide the system to find_system as a handle. Search for block dialog box parameters with a value of 0. If you make multiple calls to get_param for the same block, then using the block handle is more efficient than specifying the full block path as a character vector.

load_system('vdp');
sys = get_param('vdp','Handle');
find_system(sys,'BlockDialogParams','0')

Input Arguments

collapse all

`System` — System to search
path name | cell array of path names | handle | vector of handles

System to search, specified as the full system path name, a cell array of system path names, a handle, or a vector of handles.

Example: 'MyModel/Subsystem1'

Example: {'vdp','ex_sldemo_clutch'}

Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Before R2021a, use commas to separate each name and value, and enclose Name in quotes.

Example: 'SearchDepth','0','LookUnderMasks','none','BlockType','Goto' searches in loaded systems, excluding masked subsystems, for Goto blocks.

When you use the find_system function, Name,Value pair arguments can include search constraints and parameter name and value pairs. You can specify search constraints in any order, but they must precede the parameter name and value pairs.

See Block-Specific Parameters for the list of block parameters.

`BlockDialogParams` — Option to search block dialog box parameters for the specified value
character vector | string scalar

Option to search block dialog box parameters for the specified value, specified as the comma-separated pair consisting of 'BlockDialogParams' and a character vector or string scalar. This pair must follow the other search constraint pairs.

`CaseSensitive` — Option to consider case when matching
`'on'` (default) | `'off'`

Option to consider case when matching, specified as the comma-separated pair consisting of 'CaseSensitive' and 'on' for case-sensitive searching or 'off'.

`FindAll` — Option to include lines, ports, and annotations within systems
`'off'` (default) | `'on'`

Option to include lines, ports, and annotations in systems in the search, specified as the comma-separated pair consisting of 'FindAll' and 'on' or 'off'.When this option is set to 'on', find_system returns a vector of handles regardless of how you specify the System argument .

`FirstResultOnly` — Option to return only the first result
`'off'` (default) | `'on'`

Option to return only the first result and then stop the search, specified as the comma-separated pair consisting of 'FirstResultOnly' and 'on' or 'off'.

`LookInsideSubsystemReference` — Option to look inside a referenced subsystem
`'on'` (default) | `'off'`

Option to look inside a referenced subsystem in a model and list child blocks specified as the comma-separated pair consisting of 'LookInsideSubsystemReference' and 'on' or 'off'.

`FollowLinks` — Option to follow links into library blocks
`'off'` (default) | `'on'`

Option to follow links into library blocks, specified as the comma-separated pair consisting of 'FollowLinks' and 'on' or 'off'. If you do not specify a system to search, find_system includes loaded libraries in the results, whether you set 'FollowLinks' to 'on' or 'off'. You can use 'FollowLinks' with 'LookUnderMasks' to update library links in subsystems. See Update Library Links in a Subsystem.

`IncludeCommented` — Option to include commented blocks
`'off'` (default) | `'on'`

Option to include commented blocks in the search, specified as the comma-separated pair consisting of 'IncludeCommented' and 'on' or 'off'.

`LoadFullyIfNeeded` — Option to load any partially loaded models
`'on'` (default) | `'off'`

Option to load any partially loaded models, specified as the comma-separated pair of 'LoadFullyIfNeeded' and 'on' to load models or 'off' to disable loading. Use this option, for example, to prevent load warnings.

`LookUnderMasks` — Options for searching under masks
`'graphical'` (default) | `'none'` | `'functional'` | `'all'` | `'on'` | `'off'`

Options for searching under masks, specified as the comma-separated pair consisting of 'LookUnderMasks' and one of these options:

'graphical' — Search includes masked subsystems that have no workspaces and no dialogs.
'none' — Search skips masked subsystems.
'functional' — Search includes masked subsystems that do not have dialogs.
'all' — Search includes all masked subsystems.
'on' — Search includes all masked subsystems.
'off' — Search skips masked subsystem.

`RegExp` — Option to treat search expressions as regular expressions
`'off'` (default) | `'on'`

Option to treat search expressions as regular expressions specified as the comma-separated pair consisting of 'RegExp' and 'on' to treat search expressions as regular expressions or 'off'. To learn more about MATLAB^® regular expressions, see Regular Expressions.

`SearchDepth` — Option to restrict the search depth
positive integer character vector or string scalar

Option to restrict the search depth to the specified level, specified as the comma-separated pair consisting of 'SearchDepth' and a positive integer character vector or string scalar. For example, specify '0' to search loaded systems only, '1' for blocks and subsystems of the top-level system, '2' for the top-level system and its children, etc. The default is to search all levels.

`Variants` — Options for searching variants
`'ActiveVariants'` (default) | `'AllVariants'` | `'ActivePlusCodeVariants'`

Note

The Variants argument will be removed. Use MatchFilter instead. For more information, see Compatibility Considerations.

Options for searching variants, specified as the comma-separated pair consisting of 'Variants' and one of these options:

'ActiveVariants' — Search only the active variant choice in the Variant Subsystem.
'AllVariants' — Search all variant choices in the Variant Subsystem.
'ActivePlusCodeVariants' — Search all variant choices in the Variant Subsystem that are active in simulation and is part of the generated code.

This search constraint applies only to Variant Subsystem blocks that have the Variant control mode set to expression or label. Use the find_system function with the MatchFilter option to operate on all types of variant blocks.

`MatchFilter` — Option to match and filter elements in search
function handle

Option to match and filter elements such as blocks, system, lines, ports, and annotations in a search, specified as function handle. Use MatchFilter to determine whether elements should be included or skipped in a search.

The argument:

Allows you to filter elements with custom filter functions
Avoids processing elements when filters do not match
Applies complex filters on blocks, lines, or annotations, to filter the results internally

The named function must be defined within a MATLAB program file. The function takes the handle of the element as input and returns two outputs.

 function [match, prune] = func(element)

The input element is the handle of the block being processed.
The first output, match, is a logical value. If false, search skips the element.
The second output, prune, is an optional logical value that only applies when element is a subsystem. The default value is false. If this value is set to true, the entire subsystem is omitted from the search.

Example: Use MatchFilter to find all non Inport and Outport blocks in a model using your own defined filter function, nonInOutBlocks.

function match = nonInOutBlocks(handle)
match = true;
if strcmp(get_param(handle, 'Type'), 'block')
  blockType = get_param(handle, 'BlockType');
  if strcmp(blockType, 'Inport') || ...
        strcmp(blockType,  'Outport')
      match = false;
  end
end
end

load_system('vdp');
blks = find_system('vdp', 'MatchFilter', @nonInOutBlocks)

Variants: Simulink^® provides these built-in match filter functions to find variant blocks that are active in simulation or part of the generated code.

Simulink.match.activeVariants — Filter function to find blocks that are active in simulation after model compilation.
Simulink.match.codeCompileVariants — Filter function to find blocks that are part of generated code after model compilation.
Simulink.match.allVariants — Filter function to find all blocks irrespective of whether the block is active or inactive due to variants.
Simulink.match.variantAssemblySubsystems — Filter function to find all the Variant Assembly Subsystem blocks.

Note

To get correct results, you must compile the model before using Simulink.match.activeVariants and Simulink.match.codeCompileVariants filters. If the model is not compiled, these filters return all blocks in the model.

For an example that compares the pre-compile and post-compile time results for these filters, see Use find_system with Built-In MatchFilter Options for Variant Blocks.

Example: Use the Simulink.match.activeVariants filter to find active variants in a model.

openExample('simulink_variants/BuiltInMatchFiltersWithfindsystemForVariantBlocksExample');
model='sldemo_variant_subsystems';
load_system(model);
assignin('base','VSS_MODE',2);
set_param(model, 'SimulationCommand', 'update');
activeBlks = find_system(model, 'MatchFilter', @Simulink.match.activeVariants);

Example: Use the Simulink.match.codeCompileVariants filter to find variant choices that are part of the generated C code.

openExample('simulink_variants/BuiltInMatchFiltersWithfindsystemForVariantBlocksExample');
load_system('sldemo_variant_subsystems');
assignin('base','VSS_MODE',2);
sldemo_variant_subsystems([], [], [], 'compileForCodegen');
activeBlks= find_system('sldemo_variant_subsystems', 'MatchFilter', @Simulink.match.codeCompileVariants);
sldemo_variant_subsystems([], [], [], 'term');

Example: Use the Simulink.match.allVariants() filter to find all blocks in a model.

 find_system('sldemo_variant_subsystems', 'MatchFilter', @Simulink.match.allVariants);

Example: Use the Simulink.match.variantAssemblySubsystems() filter to find all the Variant Assembly Subsystem blocks in a model.

openExample('simulink_variants/ChoicesMaskVariantAssemblySubsystemMaskParamObjectExample');
load_system('slexVariantAssemblySubsystemWithMask')
find_system('slexVariantAssemblySubsystemWithMask', 'MatchFilter', @Simulink.match.variantAssemblySubsystems)

Output Arguments

collapse all

`Objects` — Matching objects
cell array of path names | vector of handles

Matching objects found, returned as:

A cell array of path names if you specified System as a path name or cell array of path names, or if you did not specify a system
A vector of handles if you specified System as a handle or vector of handles

Version History

Introduced before R2006a

expand all

R2022b: Warnings for removal of `Variants` argument

As part of the removal of the Variants argument in a future release, these warnings have been introduced:

When you use the find_system function without the Variants argument, the function generates a warning if it skips the inactive choice of a Variant Subsystem block during the search.

Consider a model with a Variant Subsystem block that has two variant choices, Linear Controller and Nonlinear Controller. The Nonlinear Controller block is the active choice.

This command skips the inactive Linear Controller block and generates a warning.

blocks = find_system('sldemo_variant_subsystems/Controller')

Warning: Using find_system without the 'Variants' argument skips inactive Variant Subsystem blocks in the search.
This behavior will change in a future release to look at all choices of the Variant Subsystem. To find blocks that
are active in simulation or code generation, compile the model and use the built-in variant filters with the
'MatchFilter' option.

blocks =

  12×1 cell array

    {'sldemo_variant_subsystems/Controller'                                      }
    {'sldemo_variant_subsystems/Controller/sensor1'                              }
    {'sldemo_variant_subsystems/Controller/sensor2'                              }
    {'sldemo_variant_subsystems/Controller/sensor3'                              }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller'                 }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor1'         }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor2'         }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor3'         }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/1-D Lookup Table'}
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'             }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Out1'            }
    {'sldemo_variant_subsystems/Controller/Out1'                                 }

When you use the Variants argument with its value set to 'AllVariants', the function generates a warning.

blocks = find_system('sldemo_variant_subsystems/Controller','Variants','AllVariants')

Warning: 'Variants' will be removed. Instead of using 'Variants' with value set to 'AllVariants',
use 'MatchFilter' with value set to @Simulink.match.allVariants.

blocks =

  19×1 cell array

    {'sldemo_variant_subsystems/Controller'                                         }
    {'sldemo_variant_subsystems/Controller/sensor1'                                 }
    {'sldemo_variant_subsystems/Controller/sensor2'                                 }
    {'sldemo_variant_subsystems/Controller/sensor3'                                 }
    {'sldemo_variant_subsystems/Controller/Linear Controller'                       }
    {'sldemo_variant_subsystems/Controller/Linear Controller/sensor1'               }
    {'sldemo_variant_subsystems/Controller/Linear Controller/sensor2'               }
    {'sldemo_variant_subsystems/Controller/Linear Controller/sensor3'               }
    {'sldemo_variant_subsystems/Controller/Linear Controller/Add'                   }
    {'sldemo_variant_subsystems/Controller/Linear Controller/Discrete↵Transfer Fcn'}
    {'sldemo_variant_subsystems/Controller/Linear Controller/Out1'                  }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller'                    }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor1'            }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor2'            }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/sensor3'            }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/1-D Lookup Table'   }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'                }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Out1'               }
    {'sldemo_variant_subsystems/Controller/Out1'                                    }

R2022a: New built-in match filter to find all variant blocks

You can use the built-in match filter, Simulink.match.allVariants, to find all the blocks in a variant model regardless of whether the block is active or inactive due to variants. This filter is the recommended replacement for the AllVariants option.

To be removed	Recommended Replacement
find_system(model,'Variants', ... 'AllVariants');	find_system(model,'MatchFilter', ... @Simulink.match.allVariants);

R2021a: Default behavior has changed for `Variants` and `MatchFilter` arguments in model with variant blocks

Variants: When you use the find_system function without specifying the Variants argument, the function currently includes only the active variant choice for Variant Subsystem blocks in the search by default.
For other variant blocks such as Variant Source, Variant Sink, or Variant Subsystem blocks with the Propagate conditions outside of variant subsystem parameter set to on, the function includes all choices in the search.
Consider a model with a Variant Subsystem that has two variant choices, Linear Controller and Nonlinear Controller.
This command returns only the active Add blocks in the model.
```
add_blocks = find_system('sldemo_variant_subsystems/Controller',...
'BlockType','Sum')
```
```
add_blocks =

  1×1 cell array

    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'}
```
MatchFilter: When you use the find_system function with the MatchFilter argument, the function applies the filters on the active and inactive variant choices by default.
Consider a model with a Variant Subsystem that has two variant choices, Linear Controller and Nonlinear Controller. The filter function findAddBlocks finds all the Add blocks in the model.
```
 function match = findAddBlocks(handle)
 match = strcmp(get_param(handle, 'Type'), 'block') &&...
 strcmp(get_param(handle, 'BlockType'), 'Sum');
 end
```
This command returns the active and inactive Add blocks in the model.
```
add_blocks = find_system('sldemo_variant_subsystems','MatchFilter',...
@findAddBlocks)
```
```
add_blocks =

  2×1 cell array

    {'sldemo_variant_subsystems/Controller/Linear Controller/Add'   }
    {'sldemo_variant_subsystems/Controller/Nonlinear Controller/Add'}
```

R2021a: `Variants` argument will be removed

The Variants argument will be removed from find_system in a future release. Function calls that use the Variants argument continue to work with a warning.

Using the find_system function with the Variants argument produces inconsistent search results. The find_system function is an edit-time operation, but to determine whether a block is active in a model with all types of variant blocks, you need to compile the model.

To find variant blocks that are active during simulation or code generation, compile the model and use the find_system function with the MatchFilter argument.

This table lists the recommended replacement for different values of the Variants argument.

To Be Removed	Recommended Replacement
find_system(model,'Variants', ... 'ActiveVariants');	set_param(model,'SimulationCommand','update'); find_system(model,'MatchFilter', ... @Simulink.match.activeVariants);
find_system(model,'Variants', ... 'ActivePlusCodeVariants');	model([], [], [], 'compileForCodegen'); activeBlks= find_system(model,'MatchFilter', ... @Simulink.match.codeCompileVariants); model([], [], [], 'term');

To Be Removed

Recommended Replacement

find_system(model,'Variants', ...
'ActiveVariants');

set_param(model,'SimulationCommand','update');
find_system(model,'MatchFilter', ...
@Simulink.match.activeVariants);

find_system(model,'Variants', ...
'ActivePlusCodeVariants');

model([], [], [], 'compileForCodegen');
activeBlks= find_system(model,'MatchFilter', ...
@Simulink.match.codeCompileVariants);
model([], [], [], 'term');

When you use the find_system function, you cannot specify both of the MatchFilter and Variants arguments.

This command produces an error.

find_system(bdroot,'MatchFilter',@Simulink.match.activeVariants,...
    'Variants','ActiveVariants');

R2020b: Filter elements during search with `MatchFilter`

To match and filter model elements during a search, you can define a custom filter function and pass the function handle as value to the MatchFilter name-value argument.

To find variant blocks that are active in a simulation or part of the generated code, you can use the built-in match filter functions, Simulink.match.activeVariants, Simulink.match.codeCompileVariants, and Simulink.match.allVariants, after compiling the model.

find_system

Syntax

Description

Examples

Find Loaded Systems and Their Blocks

Find Specific System and Its Blocks

Return Names of Loaded Models, Subsystems, and Libraries

Search Children of Subsystem

Search Using Multiple Criteria

Return Lines and Annotations as Handles

Search for Specific Block Parameter Value

Search Using Regular Expressions

Regular Expression Search for Partial Match

Update Library Links in a Subsystem

Return Values as Handles

Input Arguments

System — System to search path name | cell array of path names | handle | vector of handles

Name-Value Arguments

BlockDialogParams — Option to search block dialog box parameters for the specified value character vector | string scalar

CaseSensitive — Option to consider case when matching 'on' (default) | 'off'

FindAll — Option to include lines, ports, and annotations within systems 'off' (default) | 'on'

FirstResultOnly — Option to return only the first result 'off' (default) | 'on'

LookInsideSubsystemReference — Option to look inside a referenced subsystem 'on' (default) | 'off'

FollowLinks — Option to follow links into library blocks 'off' (default) | 'on'

IncludeCommented — Option to include commented blocks 'off' (default) | 'on'

LoadFullyIfNeeded — Option to load any partially loaded models 'on' (default) | 'off'

LookUnderMasks — Options for searching under masks 'graphical' (default) | 'none' | 'functional' | 'all' | 'on' | 'off'

RegExp — Option to treat search expressions as regular expressions 'off' (default) | 'on'

SearchDepth — Option to restrict the search depth positive integer character vector or string scalar

Variants — Options for searching variants 'ActiveVariants' (default) | 'AllVariants' | 'ActivePlusCodeVariants'

MatchFilter — Option to match and filter elements in search function handle

Output Arguments

Objects — Matching objects cell array of path names | vector of handles

Version History

R2022b: Warnings for removal of Variants argument

R2022a: New built-in match filter to find all variant blocks

R2021a: Default behavior has changed for Variants and MatchFilter arguments in model with variant blocks

R2021a: Variants argument will be removed

R2020b: Filter elements during search with MatchFilter

See Also

Topics

`System` — System to search
path name | cell array of path names | handle | vector of handles

`BlockDialogParams` — Option to search block dialog box parameters for the specified value
character vector | string scalar

`CaseSensitive` — Option to consider case when matching
`'on'` (default) | `'off'`

`FindAll` — Option to include lines, ports, and annotations within systems
`'off'` (default) | `'on'`

`FirstResultOnly` — Option to return only the first result
`'off'` (default) | `'on'`

`LookInsideSubsystemReference` — Option to look inside a referenced subsystem
`'on'` (default) | `'off'`

`FollowLinks` — Option to follow links into library blocks
`'off'` (default) | `'on'`

`IncludeCommented` — Option to include commented blocks
`'off'` (default) | `'on'`

`LoadFullyIfNeeded` — Option to load any partially loaded models
`'on'` (default) | `'off'`

`LookUnderMasks` — Options for searching under masks
`'graphical'` (default) | `'none'` | `'functional'` | `'all'` | `'on'` | `'off'`

`RegExp` — Option to treat search expressions as regular expressions
`'off'` (default) | `'on'`

`SearchDepth` — Option to restrict the search depth
positive integer character vector or string scalar

`Variants` — Options for searching variants
`'ActiveVariants'` (default) | `'AllVariants'` | `'ActivePlusCodeVariants'`

`MatchFilter` — Option to match and filter elements in search
function handle

`Objects` — Matching objects
cell array of path names | vector of handles

R2022b: Warnings for removal of `Variants` argument

R2021a: Default behavior has changed for `Variants` and `MatchFilter` arguments in model with variant blocks

R2021a: `Variants` argument will be removed

R2020b: Filter elements during search with `MatchFilter`