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

查找特定模型及其模块

打开实时脚本

打开示例。然后，加载 vdp 和 ex_sldemo_clutch 模型。

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

查找 vdp 模型及其模块。

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

查找加载的模型、子系统和库

打开实时脚本

打开示例。然后，加载 vdp 模型。

load_system('vdp')

查找所有加载的模型、子系统和库。仅当子系统可以独立加载时，才会返回子系统名称。

find_system('type','block_diagram')

ans = 1x1 cell array
    {'vdp'}

搜索子系统的子级

打开实时脚本

打开示例。然后，加载 ex_sldemo_clutch 模型。

load_system('ex_sldemo_clutch')

返回作为 ex_sldemo_clutch 模型中的 Unlocked 子系统的子级存在的所有 Goto 模块的名称。

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

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

使用多个条件进行搜索

打开实时脚本

打开示例。然后，加载 vdp 模型。

load_system('vdp')

在 vdp 模型中查找满足以下两个条件的模块。

该模块是 Integrator 模块。
初始条件的值为 0。

find_system('vdp','BlockType','Integrator','InitialCondition','0')

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

查找信号线和注解

打开实时脚本

打开示例。然后，加载 vdp 模型。

load_system('vdp')

使用 find_system 函数查找 vdp 模型中的信号线。要在搜索中包括信号线，请将 'FindAll' 指定为 'on'。

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

使用 find_system 函数在 vdp 模型中查找注解。要在搜索中包括注解，请将 'FindAll' 指定为 'on'。

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

搜索特定的模块参数值

打开实时脚本

打开示例。然后，加载 vdp 和 f14 模型。

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

在 vdp 和 f14 模型中查找任何具有 Block Dialog 框参数且其值为 3 的模块。

find_system(models,'BlockDialogParams','3')

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

使用正则表达式进行搜索

打开实时脚本

打开示例。然后，加载 ex_sldemo_clutch 和 vdp 模型。

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

在当前加载的模型的顶层查找“模块参数”对话框参数值以 3 开头的所有模块。

find_system('SearchDepth','1','regexp','on','BlockDialogParams','^3')

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

正则表达式搜索部分匹配

打开实时脚本

使用正则表达式进行搜索时，您可以指定要匹配的字符向量的一部分，以返回包含该字符向量的所有对象。

查找 ex_sldemo_clutch 模型中的所有 Integrator 模块。

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

更新子系统中的库链接

假设您有一个名为 myModel 的模型，它包含一个库链接子系统。上次打开模型后，向库中对应的子系统中添加了一个 Gain 模块。

打开模型。使用 find_system 并将 'FollowLinks' 设置为 'off'。此命令不会跟随库链接进入子系统，并且只返回顶层子系统。

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

ans = 

    'myModel'
    'myModel/Subsystem'

使用 find_system 并将 'FollowLinks' 设置为 'on'。find_system 将更新库链接，并返回子系统中的模块。

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

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

ans = 

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

以句柄形式返回值

打开实时脚本

如果您进行多个函数调用且这些调用要求您指定函数所作用的模型或模块，请使用句柄而不是文件路径来指定模型或模块。

如果要对 find_system 函数进行多次调用，请将 vdp model 指定为句柄。

打开示例。然后，加载 vdp 模型。

load_system('vdp')

获取 vdp 模型的句柄。

h = get_param('vdp','Handle')

h = 
152.0021

查找 vdp 模型中值为 0 的“模块参数”对话框参数。将要搜索的模型指定为 vdp 模型的句柄。

find_system(h,'BlockDialogParams','0')

在 vdp 模型中查找“模块参数”对话框参数值以 3 开头的模块参数。将要搜索的模型指定为 vdp 模型的句柄。

find_system(h,'regexp','on','BlockDialogParams','^3')

ans = 
175.0079

在 vdp 模型中查找模块名称包含字符向量 'port' 的模块。将要搜索的模型指定为 vdp 模型的句柄。

find_system(h,'regexp','on','blocktype','port')

ans = 2×1

  195.0037
  197.0045

使用自定义 `MatchFilter` 函数过滤 `find_system` 搜索

打开实时脚本

将 MatchFilter 参量与自定义过滤器函数结合使用，在 vdp 模型中查找除 Inport 和 Outport 模块之外的模块。

此示例的自定义函数在文件 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

提供函数句柄作为 MatchFilter 参量的值。

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

使用 `find_system` 和内置的 `MatchFilter` 函数查找变体模块

此示例使用:

打开实时脚本

Simulink® 提供内置函数，可用于查找模型中的变体模块。有关详细信息，请参阅MatchFilter.

加载 slexVariantSubsystems 模型。

model = 'slexVariantSubsystems';
load_system(model);
assignin('base','VSS_MODE',2);

使用 Simulink.match.activeVariants 函数查找模型编译后在仿真中活动的变体模块。

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

使用 Simulink.match.codeCompileVariants 函数查找模型编译后生成的 C 代码中的变体选择项。

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

注意：为了获得正确的结果，在使用 Simulink.match.activeVariants 和 Simulink.match.codeCompileVariants 过滤器之前，您必须编译模型。如果模型未编译，这些过滤器将返回模型中的所有模块。

使用 Simulink.match.allVariants 函数查找所有模块的过滤器函数，而不管该模块是否因变体而处于活动或非活动状态。

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

使用 Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoice 函数查找在仿真中处于活动状态或在编辑时作为生成代码一部分的可变子系统模块选择项。有关编辑时过滤器的限制的信息，请参阅 MatchFilter。

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

使用 Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices 函数查找在编辑时处于活动状态的可变子系统模块选择项。有关编辑时过滤器的限制的信息，请参阅 MatchFilter。

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

使用 Simulink.match.variantAssemblySubsystems 函数在 slexVariantAssemblySubsystemWithMaskInLabel 模型中查找所有 Variant Assembly Subsystem 模块。

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

比较变体模块的匹配过滤器的编译前和编译后行为

此示例使用:

打开实时脚本

此示例比较内置 find_system MatchFilter 函数的编译前和编译后结果，以查找变体模块。这些过滤器有助于查找在仿真中处于活动状态或作为生成代码一部分的变体模块：

Simulink.match.activeVariants
Simulink.match.codeCompileVariants

打开模型 slexVariantSubsystems。该模型配置为使用 Embedded Coder® 生成代码，并使用基于 ERT 的系统目标文件 ert.tlc。

model="slexVariantSubsystems";
open_system(model);

2.将 Controller 模块的 VariantActivationTime 参数设置为 code compile。对于此激活时间，使用 Embedded Coder 生成的代码同时包括活动和非活动变体选择项。

set_param('slexVariantSubsystems/Controller','VariantActivationTime','code compile');

3.对于 Controller 模块的选择项，将 TreatAsAtomicUnit 参数设置为 on。需要执行此步骤以使用 Controller 模块的 code compile 激活时间。

set_param('slexVariantSubsystems/Controller/Linear Controller', 'TreatAsAtomicUnit', 'on');
set_param('slexVariantSubsystems/Controller/Nonlinear Controller', 'TreatAsAtomicUnit', 'on');

模型编译前的 find_system 结果

在编译模型之前使用内置的匹配过滤器将返回模型中的所有模块，而不考虑其变体活动性。

find_system(model,MatchFilter=@Simulink.match.activeVariants)

ans = 25x1 cell
    {'slexVariantSubsystems'                                                 }
    {'slexVariantSubsystems/Controller'                                      }
    {'slexVariantSubsystems/Controller/sensor1'                              }
    {'slexVariantSubsystems/Controller/sensor2'                              }
    {'slexVariantSubsystems/Controller/sensor3'                              }
    {'slexVariantSubsystems/Controller/Linear Controller'                    }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'            }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete...'        }
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'}
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'             }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'            }
    {'slexVariantSubsystems/Controller/Out1'                                 }
    {'slexVariantSubsystems/Scope'                                           }
    {'slexVariantSubsystems/sine1'                                           }
    {'slexVariantSubsystems/sine2'                                           }
    {'slexVariantSubsystems/sine3'                                           }
    {'slexVariantSubsystems/Out1'                                            }

find_system(model,MatchFilter=@Simulink.match.codeCompileVariants)

ans = 25x1 cell
    {'slexVariantSubsystems'                                                 }
    {'slexVariantSubsystems/Controller'                                      }
    {'slexVariantSubsystems/Controller/sensor1'                              }
    {'slexVariantSubsystems/Controller/sensor2'                              }
    {'slexVariantSubsystems/Controller/sensor3'                              }
    {'slexVariantSubsystems/Controller/Linear Controller'                    }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'            }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete...'        }
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'}
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'             }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'            }
    {'slexVariantSubsystems/Controller/Out1'                                 }
    {'slexVariantSubsystems/Scope'                                           }
    {'slexVariantSubsystems/sine1'                                           }
    {'slexVariantSubsystems/sine2'                                           }
    {'slexVariantSubsystems/sine3'                                           }
    {'slexVariantSubsystems/Out1'                                            }

模型编译后的 find_system 结果

编译模型。

set_param(model,"SimulationCommand","update");

使用 Simulink.match.activeVariants 过滤器将返回在仿真中处于活动状态的模块。

find_system(model,MatchFilter=@Simulink.match.activeVariants)

ans = 18x1 cell
    {'slexVariantSubsystems'                                         }
    {'slexVariantSubsystems/Controller'                              }
    {'slexVariantSubsystems/Controller/sensor1'                      }
    {'slexVariantSubsystems/Controller/sensor2'                      }
    {'slexVariantSubsystems/Controller/sensor3'                      }
    {'slexVariantSubsystems/Controller/Linear Controller'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'    }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'    }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'    }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'        }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete...'}
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'       }
    {'slexVariantSubsystems/Controller/Out1'                         }
    {'slexVariantSubsystems/Scope'                                   }
    {'slexVariantSubsystems/sine1'                                   }
    {'slexVariantSubsystems/sine2'                                   }
    {'slexVariantSubsystems/sine3'                                   }
    {'slexVariantSubsystems/Out1'                                    }

使用 Simulink.match.codeCompileVariants 过滤器将返回作为生成的 C 代码的一部分的模块。

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

ans = 25x1 cell
    {'slexVariantSubsystems'                                                 }
    {'slexVariantSubsystems/Controller'                                      }
    {'slexVariantSubsystems/Controller/sensor1'                              }
    {'slexVariantSubsystems/Controller/sensor2'                              }
    {'slexVariantSubsystems/Controller/sensor3'                              }
    {'slexVariantSubsystems/Controller/Linear Controller'                    }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'            }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete...'        }
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'}
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'             }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'            }
    {'slexVariantSubsystems/Controller/Out1'                                 }
    {'slexVariantSubsystems/Scope'                                           }
    {'slexVariantSubsystems/sine1'                                           }
    {'slexVariantSubsystems/sine2'                                           }
    {'slexVariantSubsystems/sine3'                                           }
    {'slexVariantSubsystems/Out1'                                            }

查找所有模块而不考虑模块的活动性

使用 Simulink.match.allVariants() 滤波器查找所有模块的过滤器函数，而不管该模块是否因变体而处于活动或非活动状态。

find_system(model,MatchFilter=@Simulink.match.allVariants)

ans = 25x1 cell
    {'slexVariantSubsystems'                                                 }
    {'slexVariantSubsystems/Controller'                                      }
    {'slexVariantSubsystems/Controller/sensor1'                              }
    {'slexVariantSubsystems/Controller/sensor2'                              }
    {'slexVariantSubsystems/Controller/sensor3'                              }
    {'slexVariantSubsystems/Controller/Linear Controller'                    }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor1'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor2'            }
    {'slexVariantSubsystems/Controller/Linear Controller/sensor3'            }
    {'slexVariantSubsystems/Controller/Linear Controller/Add'                }
    {'slexVariantSubsystems/Controller/Linear Controller/Discrete...'        }
    {'slexVariantSubsystems/Controller/Linear Controller/Out1'               }
    {'slexVariantSubsystems/Controller/Nonlinear Controller'                 }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor1'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor2'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/sensor3'         }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/1-D Lookup Table'}
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Add'             }
    {'slexVariantSubsystems/Controller/Nonlinear Controller/Out1'            }
    {'slexVariantSubsystems/Controller/Out1'                                 }
    {'slexVariantSubsystems/Scope'                                           }
    {'slexVariantSubsystems/sine1'                                           }
    {'slexVariantSubsystems/sine2'                                           }
    {'slexVariantSubsystems/sine3'                                           }
    {'slexVariantSubsystems/Out1'                                            }

输入参数

全部折叠

`Model` — 要搜索的模型
路径名称 | 路径名称元胞数组 | 句柄 | 句柄向量

要搜索的模型，指定为完整的模型路径名称、模型路径名称元胞数组、句柄或句柄向量。

示例: 'MyModel/Subsystem1'

示例: {'vdp','ex_sldemo_clutch'}

名称-值参数

全部折叠

将可选参量指定为 Name1 = Value1,...,NameN = ValueN，其中 Name 是参量名称，Value 是要赋给参量的值。名称-值参量必须出现在其他参量之后。

在 R2021a 之前，使用逗号分隔每个名称和值，并用引号将 Name 引起来。

示例: SearchDepth = '0',LookUnderMasks = 'none',BlockType = 'Goto' 在加载的模型（不包括封装子系统）中搜索 Goto 模块。

使用 find_system 函数时，Name = Value 参量可以包括：

搜索条件，例如 CaseSensitive = 'on'
参数值，例如 BlockType = 'Gain'

您可以按任意顺序指定搜索条件和按任意顺序指定参数值，但搜索条件必须在参数值之前。

有关模块参数的信息，请参阅以编程方式指定模块参数和属性。

`BlockDialogParams` — 用于在模块参数中搜索指定值的选项
字符向量 | 字符串标量

用于在模块对话框参数中搜索值的选项，指定为字符向量或字符串标量。此参量必须跟在其他搜索条件参量后。

`CaseSensitive` — 用于在匹配搜索结果时考虑大小写的选项
`'on'` (默认) | `'off'`

用于在匹配时考虑文本大小写的选项，指定为 'on' 或 'off'。

`FindAll` — 用于指示在搜索中是否包括模型中的信号线、端口和注解的选项
`'off'` (默认) | `'on'`

用于在搜索中包括模型内的信号线、端口和注解的选项，指定为 'on' 或 'off'。当此选项设置为 'on' 时，无论您是将 Model 参量指定为完整模型路径名称、模型路径名称元胞数组、句柄还是句柄向量，find_system 都会返回句柄向量。

`Type` — 用于搜索特定类型的模型元素的选项
`'block'` (默认) | `'line'` | `'port'` | `'annotation'`

用于搜索特定类型的模型元素的选项，指定为以下各项之一：

'block'
'line'
'port'
'annotation'

要在模型中查找信号线、端口或注解，您必须首先将 FindAll 的值指定为 'on'，然后指定 Type 的值。您可以在 FindAll 和 Type 之前、之后和之间指定其他搜索条件选项。例如，要在名为 myModel 的模型中查找注解并在封装下查找，请在 MATLAB^® 命令行窗口中输入此命令。

find_system('myModel', FindAll =  'on',...
LookUnderMasks = 'all',Type = 'annotation')

`FirstResultOnly` — 用于只返回第一个结果然后停止搜索的选项
`'off'` (默认) | `'on'`

用于仅返回第一个结果然后停止搜索的选项，指定为 'on' 或 'off'。

`LookInsideSubsystemReference` — 用于在引用子系统中搜索的选项
`'on'` (默认) | `'off'`

用于查看模型中的引用子系统内部并列出子模块的选项，指定为 'on' 或 'off'。

`FollowLinks` — 用于指示在搜索中跟随链接进入库模块的选项
`'off'` (默认) | `'on'`

用于跟随链接进入库模块的选项，指定为 'on' 或 'off'。如果您不指定要搜索的模型，find_system 将在结果中包括已加载的库，不管您将 'FollowLinks' 设置为 'on' 还是 'off'。您可以将 'FollowLinks' 与 'LookUnderMasks' 结合使用，以更新子系统中的库链接。请参阅更新子系统中的库链接。

`IncludeCommented` — 用于指示在搜索中是否包含带注释的模块的选项
`'off'` (默认) | `'on'`

用于指示在搜索中是否包含带注释的模块的选项，指定为 'on' 或 'off'。

`LoadFullyIfNeeded` — 用于指示在搜索中是否将部分加载的模型完全加载的选项
`'on'` (默认) | `'off'`

用于指示是否将部分加载的模型完全加载的选项，指定为 'on'（表示加载模型）或 'off'（表示禁用加载）。例如，使用此选项可以防止出现加载警告。

`LookUnderMasks` — 用于指示如何搜索封装子系统的选项
`'graphical'` (默认) | `'none'` | `'functional'` | `'all'`

用于指示如何搜索封装子系统的选项，指定为以下各项之一：

'none' - 搜索将跳过封装子系统。
'all' - 搜索包括所有封装子系统。
'functional' - 搜索包括具有图标绘图命令或封装初始化命令但没有参数、描述、帮助字符串和 UI 元素的封装子系统。
'graphical' - 搜索包括只有图标绘图命令而没有工作区、对话框、帮助字符串和 UI 元素的封装子系统。

注意

选项 'none' 取代了以前的选项 'off'。选项 'all' 取代了以前的选项 'on'。

`RegExp` — 用于将搜索表达式视为正则表达式的选项
`'off'` (默认) | `'on'`

用于将搜索表达式视为正则表达式的选项，指定为 'on' 或 'off'。当 'RegExp' 设置为 'on' 时，搜索将搜索表达式视为正则表达式。有关 MATLAB 正则表达式的详细信息，请参阅正则表达式。

`SearchDepth` — 用于限制搜索路径的选项
正整数字符向量或字符串标量

用于将搜索深度限制在指定级别的选项，指定为正整数、字符向量或字符串标量。例如，指定 '0' 将仅搜索加载的模型，指定 '1' 将搜索模型层次结构顶层的模块和子系统，指定 '2' 将搜索模型层次结构的顶层及其子级，以此类推。默认值为搜索所有级别。

`Variants` — 用于搜索变体的选项
`'ActiveVariants'` (默认) | `'AllVariants'` | `'ActivePlusCodeVariants'`

注意

Variants 参量将被删除。请改用 MatchFilter。有关详细信息，请参阅版本历史记录。

用于搜索变体的选项，指定为以下各项之一：

'ActiveVariants' - 仅搜索 Variant Subsystem 中的活动变体选择项。
'AllVariants' - 搜索 Variant Subsystem 中的所有变体选择项。
'ActivePlusCodeVariants' - 搜索 Variant Subsystem 中的在仿真中处于活动状态并且是生成代码一部分的所有变体选择项。

此搜索约束仅适用于变体控制项模式设置为 expression 或 label 的 Variant Subsystem 模块。将 find_system 函数与 MatchFilter 选项结合使用，可对所有类型的变体模块进行操作。

`MatchFilter` — 在搜索中匹配和过滤元素的选项
函数句柄

用于在搜索中匹配和过滤元素（如模块、模型、信号线、端口和注解）的选项，指定为函数句柄。使用 MatchFilter 确定在搜索中应包括还是跳过元素。

参量：

允许您使用自定义过滤器函数过滤元素
在过滤器不匹配时避免处理元素
对模块、信号线或注解应用复杂过滤器，以在内部过滤结果

命名函数必须在 MATLAB 程序文件中定义。该函数将元素的句柄作为输入，并返回两个输出。

 function [match, prune] = func(element)

输入 element 是正在处理的组件的句柄，例如模块句柄。
第一个输出 match 是逻辑值。如果为 false，搜索将跳过该元素。
第二个输出 prune 是可选的逻辑值，仅在 element 是子系统时适用。默认值为 false。如果此值设置为 true，则搜索中将忽略整个子系统。

有关说明如何创建自定义匹配过滤器函数的示例，请参阅使用自定义 MatchFilter 函数过滤 find_system 搜索。

变体：Simulink^® 提供这些内置的匹配过滤器函数来查找变体模块。

编译后过滤器函数：

Simulink.match.activeVariants - 过滤器函数，用于查找模型编译后在仿真中处于活动状态的模块。
Simulink.match.codeCompileVariants - 过滤器函数，用于查找在模型编译后作为生成代码一部分的模块。
Simulink.match.allVariants - 用于查找所有模块的过滤器函数，而不管该模块是否因变体而处于活动或非活动状态。
Simulink.match.variantAssemblySubsystems - 用于查找所有 Variant Assembly Subsystem 模块的过滤器函数。

有关说明如何使用这些过滤器的示例，请参阅使用 find_system 和内置的 MatchFilter 函数查找变体模块。

注意

为了获得正确的结果，在使用 Simulink.match.activeVariants 和 Simulink.match.codeCompileVariants 过滤器之前，您必须编译模型。如果模型未编译，这些过滤器将返回模型中的所有模块。有关比较这些过滤器的编译前和编译后时间结果的示例，请参阅比较变体模块的匹配过滤器的编译前和编译后行为。

Variant Subsystem 模块的编辑时过滤器函数：

Simulink.match.legacy.filterOutCodeInactiveVariantSubsystemChoices - 用于查找 Variant Subsystem 模块选择项的过滤器函数，这些模块选择项在仿真中处于活动状态或者作为生成代码的一部分。此函数产生的结果与 Variants 参量的 'ActivePlusCodeVariants' 选项类似。
Simulink.match.legacy.filterOutInactiveVariantSubsystemChoices - 查找处于活动状态的 Variant Subsystem 模块选择项的过滤器函数。此函数产生的结果与 Variants 参量的 'ActiveVariants' 选项类似。

编辑时过滤器的限制：

过滤器不使用 CompiledVariantInfo 模块参数中的编译后模块活动性信息。
过滤器仅适用于具有以下模块参数设置的 Variant Subsystem 模块：
- 变体控制项模式设置为表达式或标签
- 将条件传播到可变子系统之外设置为 off
仅在 find_system、find_mdlrefs 和 Simulink.FindOptions 的上下文中使用时，过滤器才能识别模块句柄是否在 Variant Subsystem 的活动选择项内。

要对所有类型的变体模块进行操作，请在模型编译后使用 Simulink.match.codeCompileVariants 或 Simulink.match.activeVariants 过滤器。

`SegmentType` — 用于搜索特定类型的信号线段的选项
`'trunk'` | `'branch'`

用于搜索特定类型的信号线段的选项，指定为以下各项之一：

'trunk' - 连接到输出端口或未连接到信号源的线段
'branch' - 连接到主干的线段

要查找特定类型的信号线段，您必须先将 FindAll 的值指定为 'on'，然后将 Type 的值指定为 'line'，再指定 SegmentType 的值。您可以在 FindAll、Type 和 SegmentType 选项之前、之后和之间指定其他搜索条件选项。例如，要在名为 myModel 的模型中查找作为主干并在封装内部查找的信号线段，请在 MATLAB 命令行窗口中输入以下命令。

trunkSegments = find_system('myModel',FindAll = 'on',..
LookUnderMasks = 'all',type='line',SegmentType = 'trunk');

输出参量

全部折叠

`Objects` — 匹配对象
路径名称元胞数组 | 句柄向量

找到匹配对象，以路径名称元胞数组或句柄向量形式返回。

当以下两个条件都满足时，找到的对象将以路径名称元胞数组的形式返回。

搜索条件选项 FindAll 设置为其默认值 'off'。
指定了 Model 作为路径名称或路径名称元胞数组，或未指定模型。

当至少满足以下一个条件时，找到的对象将以句柄向量形式返回。

将 FindAll 的值设置为了 'on'。
将 Model 指定为了句柄或句柄向量。

版本历史记录

在 R2006a 之前推出

全部展开

R2022b: 删除 `Variants` 参量时会发出警告

由于以后的版本中会删除 Variants 参量，因此引入了以下警告：

当您使用不带 Variants 参量的 find_system 函数时，如果该函数在搜索过程中跳过 Variant Subsystem 模块的非活动选择项，则会生成警告。

以包含一个 Variant Subsystem 模块的模型为例，该模型有两个变体选择项 Linear Controller 和 Nonlinear Controller。Nonlinear Controller 模块是活动选择项。

此命令会跳过非活动的 Linear Controller 模块并生成警告。

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 thatare 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'                                 }

当您使用 Variants 参量且其值设置为 'AllVariants' 时，该函数会生成警告。

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: 新的内置匹配过滤器可用于查找所有变体模块

您可以使用内置的匹配过滤器 Simulink.match.allVariants 来查找变体模型中的所有模块，而不管该模块由于变体而处于活动状态还是非活动状态。此滤波器是 AllVariants 选项的推荐替代项。

将删除	推荐的替代项
find_system(model,'Variants', ... 'AllVariants');	find_system(model,'MatchFilter', ... @Simulink.match.allVariants);

R2021a: 在具有变体模块的模型中，`Variants` 和 `MatchFilter` 参量的默认行为已更改

Variants:当您使用 find_system 函数而未指定 Variants 参量时，默认情况下，该函数当前在搜索中仅包括 Variant Subsystem 模块的活动变体选择项。
对于 Variant Source、Variant Sink 或 Variant Subsystem 等其他变体模块，如果将条件传播到可变子系统之外参数设置为 on，该函数将在搜索中包括所有选择项。
以包含一个 Variant Subsystem 的模型为例，该模型有两个变体选择项 Linear Controller 和 Nonlinear Controller。
此命令仅返回模型中的活动 Add 模块。
```
add_blocks = find_system('sldemo_variant_subsystems/Controller',...
'BlockType','Sum')
```
```
add_blocks =

  1×1 cell array

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

MatchFilter:当您使用带 MatchFilter 参量的 find_system 函数时，默认情况下，该函数会对活动和非活动变体选择项应用过滤器。

以包含一个 Variant Subsystem 的模型为例，该模型有两个变体选择项 Linear Controller 和 Nonlinear Controller。过滤器函数 findAddBlocks 查找模型中的所有 Add 模块。

 function match = findAddBlocks(handle)
 match = strcmp(get_param(handle, 'Type'), 'block') &&...
 strcmp(get_param(handle, 'BlockType'), 'Sum');
 end

以下命令返回模型中的活动和非活动 Add 模块。

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` 参量将被删除

在以后的版本中，将从 find_system 中删除 Variants 参量。使用 Variants 参量的函数调用会继续工作，但会出现警告。

使用带 Variants 参量的 find_system 函数会产生不一致的搜索结果。find_system 函数在编辑时运行，但要确定模块在具有所有类型的变体模块的模型中是否处于活动状态，您需要编译该模型。

要查找在仿真或代码生成过程中处于活动状态的变体模块，请编译模型并使用带 MatchFilter 参量的 find_system 函数。

下表列出了 Variants 参量的不同值的建议替代项。

将删除	推荐的替代项
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');

将删除

推荐的替代项

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');

使用 find_system 函数时，不能同时指定 MatchFilter 和 Variants 参量。

以下命令会生成错误。

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

R2020b: 在搜索过程中使用 `MatchFilter` 过滤元素

要在搜索过程中匹配和过滤模型元素，您可以定义自定义过滤器函数，并将函数句柄作为值传递给 MatchFilter 名称-值参量。

要查找在仿真中处于活动状态或作为生成代码一部分的变体模块，您可以在编译模型后使用内置的匹配过滤器函数 Simulink.match.activeVariants、Simulink.match.codeCompileVariants 和 Simulink.match.allVariants。

另请参阅

find_system

语法

说明

示例

查找加载的模型和库及其模块

查找特定模型及其模块

查找加载的模型、子系统和库

搜索子系统的子级

使用多个条件进行搜索

查找信号线和注解

搜索特定的模块参数值

使用正则表达式进行搜索

正则表达式搜索部分匹配

更新子系统中的库链接

以句柄形式返回值

使用自定义 MatchFilter 函数过滤 find_system 搜索

使用 find_system 和内置的 MatchFilter 函数查找变体模块

比较变体模块的匹配过滤器的编译前和编译后行为

输入参数

Model — 要搜索的模型 路径名称 | 路径名称元胞数组 | 句柄 | 句柄向量

名称-值参数

BlockDialogParams — 用于在模块参数中搜索指定值的选项 字符向量 | 字符串标量

CaseSensitive — 用于在匹配搜索结果时考虑大小写的选项 'on' (默认) | 'off'

FindAll — 用于指示在搜索中是否包括模型中的信号线、端口和注解的选项 'off' (默认) | 'on'

Type — 用于搜索特定类型的模型元素的选项 'block' (默认) | 'line' | 'port' | 'annotation'

FirstResultOnly — 用于只返回第一个结果然后停止搜索的选项 'off' (默认) | 'on'

LookInsideSubsystemReference — 用于在引用子系统中搜索的选项 'on' (默认) | 'off'

FollowLinks — 用于指示在搜索中跟随链接进入库模块的选项 'off' (默认) | 'on'

IncludeCommented — 用于指示在搜索中是否包含带注释的模块的选项 'off' (默认) | 'on'

LoadFullyIfNeeded — 用于指示在搜索中是否将部分加载的模型完全加载的选项 'on' (默认) | 'off'

LookUnderMasks — 用于指示如何搜索封装子系统的选项 'graphical' (默认) | 'none' | 'functional' | 'all'

RegExp — 用于将搜索表达式视为正则表达式的选项 'off' (默认) | 'on'

SearchDepth — 用于限制搜索路径的选项 正整数字符向量或字符串标量

Variants — 用于搜索变体的选项 'ActiveVariants' (默认) | 'AllVariants' | 'ActivePlusCodeVariants'

MatchFilter — 在搜索中匹配和过滤元素的选项 函数句柄

SegmentType — 用于搜索特定类型的信号线段的选项 'trunk' | 'branch'

输出参量

Objects — 匹配对象 路径名称元胞数组 | 句柄向量

版本历史记录

R2022b: 删除 Variants 参量时会发出警告

R2022a: 新的内置匹配过滤器可用于查找所有变体模块

R2021a: 在具有变体模块的模型中，Variants 和 MatchFilter 参量的默认行为已更改

R2021a: Variants 参量将被删除

R2020b: 在搜索过程中使用 MatchFilter 过滤元素

另请参阅

主题

使用自定义 `MatchFilter` 函数过滤 `find_system` 搜索

使用 `find_system` 和内置的 `MatchFilter` 函数查找变体模块

`Model` — 要搜索的模型
路径名称 | 路径名称元胞数组 | 句柄 | 句柄向量

`BlockDialogParams` — 用于在模块参数中搜索指定值的选项
字符向量 | 字符串标量

`CaseSensitive` — 用于在匹配搜索结果时考虑大小写的选项
`'on'` (默认) | `'off'`

`FindAll` — 用于指示在搜索中是否包括模型中的信号线、端口和注解的选项
`'off'` (默认) | `'on'`

`Type` — 用于搜索特定类型的模型元素的选项
`'block'` (默认) | `'line'` | `'port'` | `'annotation'`

`FirstResultOnly` — 用于只返回第一个结果然后停止搜索的选项
`'off'` (默认) | `'on'`

`LookInsideSubsystemReference` — 用于在引用子系统中搜索的选项
`'on'` (默认) | `'off'`

`FollowLinks` — 用于指示在搜索中跟随链接进入库模块的选项
`'off'` (默认) | `'on'`

`IncludeCommented` — 用于指示在搜索中是否包含带注释的模块的选项
`'off'` (默认) | `'on'`

`LoadFullyIfNeeded` — 用于指示在搜索中是否将部分加载的模型完全加载的选项
`'on'` (默认) | `'off'`

`LookUnderMasks` — 用于指示如何搜索封装子系统的选项
`'graphical'` (默认) | `'none'` | `'functional'` | `'all'`

`RegExp` — 用于将搜索表达式视为正则表达式的选项
`'off'` (默认) | `'on'`

`SearchDepth` — 用于限制搜索路径的选项
正整数字符向量或字符串标量

`Variants` — 用于搜索变体的选项
`'ActiveVariants'` (默认) | `'AllVariants'` | `'ActivePlusCodeVariants'`

`MatchFilter` — 在搜索中匹配和过滤元素的选项
函数句柄

`SegmentType` — 用于搜索特定类型的信号线段的选项
`'trunk'` | `'branch'`

`Objects` — 匹配对象
路径名称元胞数组 | 句柄向量

R2022b: 删除 `Variants` 参量时会发出警告

R2021a: 在具有变体模块的模型中，`Variants` 和 `MatchFilter` 参量的默认行为已更改

R2021a: `Variants` 参量将被删除

R2020b: 在搜索过程中使用 `MatchFilter` 过滤元素