Main Content

find_system

Find models, blocks, lines, ports, and annotations

Description

example

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

example

Objects = find_system(Model) returns the specified model and its blocks.

example

Objects = find_system(Name,Value) returns loaded models and the objects in those models 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(Model,Name,Value) returns the objects in the specified model that meet the specified criteria.

Examples

collapse all

Open the example. Then, load the vdp model.

load_system('vdp')

Find all loaded models and libraries and their blocks.

find_system
ans = 13x1 cell
    {'vdp'                }
    {'vdp/Callback Button'}
    {'vdp/Constant'       }
    {'vdp/Mu'             }
    {'vdp/Product'        }
    {'vdp/Scope'          }
    {'vdp/Square'         }
    {'vdp/Sum'            }
    {'vdp/Sum1'           }
    {'vdp/x1'             }
    {'vdp/x2'             }
    {'vdp/Out1'           }
    {'vdp/Out2'           }

Open the example. Then, load the vdp and ex_sldemo_clutch models.

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

Find the vdp model and its blocks.

find_system('vdp')
ans = 13x1 cell
    {'vdp'                }
    {'vdp/Callback Button'}
    {'vdp/Constant'       }
    {'vdp/Mu'             }
    {'vdp/Product'        }
    {'vdp/Scope'          }
    {'vdp/Square'         }
    {'vdp/Sum'            }
    {'vdp/Sum1'           }
    {'vdp/x1'             }
    {'vdp/x2'             }
    {'vdp/Out1'           }
    {'vdp/Out2'           }

Open the example. Then, load the vdp model.

load_system('vdp')

Find all loaded models, subsystems, and libraries. A subsystem name is returned only if the subsystem can be loaded independently.

find_system('type','block_diagram')
ans = 1x1 cell array
    {'vdp'}

Open the example. Then, load the ex_sldemo_clutch model.

load_system('ex_sldemo_clutch')

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

find_system('ex_sldemo_clutch/Unlocked','SearchDepth',1,'BlockType','Goto')
ans = 2x1 cell
    {'ex_sldemo_clutch/Unlocked/Goto' }
    {'ex_sldemo_clutch/Unlocked/Goto1'}

Open the example. Then, load the vdp model.

load_system('vdp')

Find blocks in the vdp model that meet these two criteria.

  • The block is an Integrator block.

  • The value of Initial condition is 0.

find_system('vdp','BlockType','Integrator','InitialCondition','0')
ans = 1x1 cell array
    {'vdp/x2'}

Open the example. Then, load the vdp model.

load_system('vdp')

Find the lines in the vdp model using the find_system function. To include lines in the search, specify 'FindAll' as 'on'.

l = find_system('vdp','FindAll','on','type','line')
l = 18×1

   31.0002
   30.0002
   29.0002
   28.0002
   27.0002
   26.0002
   25.0002
   24.0002
   23.0002
   22.0002
      ⋮

Find the annotations in the vdp model using the find_system function. To include annotations in the search, specify 'FindAll' as 'on'.

an = find_system('vdp','FindAll','on','type','annotation')
an = 3×1

   34.0002
   33.0002
   32.0002

Open the example. Then, load the vdp and f14 models.

models={'vdp','f14'};
load_system(models)

Find any blocks with Block Dialog box parameters whose value is 3 in the vdp and f14 models.

find_system(models,'BlockDialogParams','3')
ans = 3x1 cell
    {'vdp/Square'                 }
    {'f14/Aircraft...'            }
    {'f14/Controller/q (rad//sec)'}

Open the example. Then, load the ex_sldemo_clutch and vdp models.

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

Find all blocks in the top level of the currently loaded models with a Block Parameters dialog box parameter value that starts with 3.

find_system('SearchDepth','1','regexp','on','BlockDialogParams','^3')
ans = 2x1 cell
    {'vdp/Square'        }
    {'ex_sldemo_clutch/w'}

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 Integrator blocks in the ex_sldemo_clutch model.

load_system('ex_sldemo_clutch');
ports=find_system('ex_sldemo_clutch','regexp','on','blocktype','Integrator')
ports = 3x1 cell
    {'ex_sldemo_clutch/Locked/Engine//Vehicle...'}
    {'ex_sldemo_clutch/Unlocked/Engine...'       }
    {'ex_sldemo_clutch/Unlocked/Vehicle...'      }

Suppose you have a model named myModel that 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'

When you make multiple function calls that require you to specify the model or block the function acts on, use handles instead of file paths to specify the model or block.

Specify the vdp model as a handle in multiple calls to the find_system function.

Open the example. Then, load the vdp model.

load_system('vdp')

Get the handle of the vdp model.

h = get_param('vdp','Handle')
h = 4.8828e-04

Find Block Parameters dialog box parameters in the vdp model with a value of 0 in the vdp model. Specify the model to search as the handle of the vdp model.

find_system(h,'BlockDialogParams','0')
ans = 8×1

    4.0005
    4.0005
    6.0005
   11.0005
   12.0005
   12.0005
   13.0005
   13.0005

Find block parameters in the vdp model with a Block Parameters dialog box parameter value that starts with 3. Specify the model to search as the handle of the vdp model.

find_system(h,'regexp','on','BlockDialogParams','^3')
ans = 7.0005

Find blocks in the vdp model whose block name contains the character vector 'port'. Specify the model to search as the handle of the vdp model.

find_system(h,'regexp','on','blocktype','port')
ans = 2×1

   12.0005
   13.0005

Use the MatchFilter argument with a custom filter function to find blocks other than Inport and Outport blocks in the vdp model.

The custom function for this example is defined in the file nonInOutBlocks.m.

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

Provide the function handle as the value of the MatchFilter argument.

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

Load the slexVariantSubsystems model.

model = 'slexVariantSubsystems';
load_system(model);
VSS_LINEAR_CONTROLLER = 
  VariantExpression with properties:

    Condition: 'VSS_MODE==1'

VSS_NONLINEAR_CONTROLLER = 
  VariantExpression with properties:

    Condition: 'VSS_MODE==2'

VSS_MODE = 2
assignin('base','VSS_MODE',2);

Use the Simulink.match.activeVariants function to find variant blocks that are active in simulation after model compilation.

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

Use the Simulink.match.codeCompileVariants function to find variant choices that are part of the generated C code after model compilation.

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

Use the Simulink.match.allVariants function to find all blocks irrespective of whether the block is active or inactive due to variants.

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

Use the Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoice function to find Variant Subsystem choice blocks that are active in simulation or part of generated code at edit-time. For information on the limitations of edit-time filters, see MatchFilter.

find_system(model, ...
 'MatchFilter',@Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoices);

Use the Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices function to find active Variant Subsystem choice blocks at edit-time. For information on the limitations of edit-time filters, see MatchFilter.

find_system(model, ...
 'MatchFilter', @Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices);

Use the Simulink.match.variantAssemblySubsystems function to find all Variant Assembly Subsystem blocks in the slexVariantAssemblySubsystemWithMaskInLabel model.

load_system('slexVariantAssemblySubsystemWithMaskInLabel');
find_system('slexVariantAssemblySubsystemWithMaskInLabel','MatchFilter',@Simulink.match.variantAssemblySubsystems);

Input Arguments

collapse all

Model to search, specified as the full model path name, a cell array of model 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.

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 models, excluding masked subsystems, for Goto blocks.

When you use the find_system function, Name,Value pair arguments can include:

  • Search constraints specified as criteria option and value pairs, for example 'CaseSensitive','on'

  • Parameter values specified as parameter name and value pairs, for example 'BlockType','Gain'

You can specify the search criteria argument pairs in any order and the parameter value argument pairs in any order, but the search criteria argument pairs must precede the parameter value argument pairs.

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

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.

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

Option to include lines, ports, and annotations in models 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 whether you specify the Model argument as the full model path name, a cell array of model path names, a handle, or a vector of handles.

Option to return only results of a specific type, specified as the comma-separated pair consisting of 'Type' and one of these options:

  • 'block'

  • 'line'

  • 'port'

  • 'annotation'

To find lines, ports, or annotations in the model, you must first specify the value of FindAll as 'on', and then specify the type. For example, to find an annotation in a model named myModel, enter this command in the command line.

find_system('myModel','FindAll','on','Type','annotation')

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'.

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'.

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 model 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.

Option to include commented blocks in the search, specified as the comma-separated pair consisting of 'IncludeCommented' and 'on' or '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.

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 has only icon drawing commands without having workspaces, dialogs, help strings, and UI elements.

  • 'none' — Search skips masked subsystems.

  • 'functional' — Search includes masked subsystems that has icon drawing commands or mask initialization commands without having parameters, description,help strings, and UI elements

  • 'all' — Search includes all masked subsystems.

  • 'on' — Search includes all masked subsystems.

  • 'off' — Search skips masked subsystem.

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

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 models only, '1' for blocks and subsystems of the top level of the model hierarchy,'2' for the top level of the model hierarchy and its children, etc. The default is to search all levels.

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.

Option to match and filter elements such as blocks, model, 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 component being processed, for example the block handle.

  • 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.

Variants: Simulink® provides these built-in match filter functions to find variant blocks.

Post-compile time filter functions:

  • 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.

Edit-time filter functions for Variant Subsystem blocks:

  • Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoices — Filter function to find Variant Subsystem choice blocks that are active in simulation or part of generated code. This function produces similar results as the 'ActivePlusCodeVariants' option of the Variants argument.

  • Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices — Filter function to find active Variant Subsystem choice blocks. This function produces similar results as the 'ActiveVariants' option of the Variants argument.

Limitations of edit-time filters:

  • The filters do not use the post-compile block activeness information in the CompiledVariantInfo block parameter.

  • The filters apply only to Variant Subsystem blocks that have these block parameter settings:

    • Variant control mode set to expression or label

    • Propagate conditions outside of variant subsystem set to off

  • The filters can identify if a block handle is inside the active choice of a Variant Subsystem only when used within the context of find_system, find_mdlrefs, and Simulink.FindOptions.

To operate on all types of variant blocks, use the Simulink.match.codeCompileVariants or Simulink.match.activeVariants filters after model compilation.

Output Arguments

collapse all

Matching objects found, returned as a cell array of path names or a vector of handles.

The objects found are returned as a cell array of path names when both of these conditions are met.

  • The search criteria option FindAll is set to its default value, 'off'.

  • You specified Model as a path name or cell array of path names, or you did not specify a model.

The objects found are returned as a vector of handles when at least one of these conditions is met.

  • You set the value of FindAll to 'on'.

  • You specified Model as a handle or vector of handles.

Version History

Introduced before R2006a

expand all