This is machine translation

Translated by Microsoft
Mouseover text to see original. Click the button below to return to the English verison of the page.

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

For Each Subsystem

Repeatedly perform algorithm on each element or subarray of input signal and concatenate results


Ports & Subsystems


The For Each Subsystem block is useful in modeling scenarios where you need to repeat the same algorithm for individual elements (or subarrays) of an input signal. The set of blocks within the subsystem represents the algorithm applied to a single element (or subarray) of the original signal. The For Each block inside the subsystem allows you to configure the decomposition of the subsystem inputs into elements (or subarrays), and to configure the concatenation of the individual results into output signals.

Inside this subsystem, each block that has states maintains separate sets of states for each element or subarray that it processes. Consequently, the operation of this subsystem is similar in behavior to copying the contents of the subsystem for each element in the original input signal and then processing each element using its respective copy of the subsystem.

An additional benefit of the For Each Subsystem is that, for certain models, it improves the code reuse in Simulink® Coder™ generated code. Consider a model containing two reusable Atomic Subsystems with the same scalar algorithm applied to each element of the signal. If the input signal dimensions of these subsystems are different, Simulink Coder generated code includes two distinct functions. You can replace these two subsystems with two identical For Each Subsystems that are configured to process each element of their respective inputs using the same algorithm. For this case, Simulink Coder generated code consists of a single function parameterized by the number of input signal elements. This function is invoked twice — once for each unique instance of the For Each Subsystem in the model. For each of these cases, the input signal elements have different values.


The For Each Subsystem block has these limitations, which you can work around.


You cannot log bus or array of bus signals directly in the For Each subsystem.

Use one of these approaches:

  • Use a Bus Selector block to select the signals you want to log and mark those signals for signal logging.

  • Attach the signal to an Outport block and log the signal outside of the For Each subsystem.

You cannot log a signal inside a referenced model that is inside a For Each subsystem if either of these conditions exists:

  • The For Each subsystem is in a model simulating in rapid accelerator mode.

  • The For Each subsystem itself is in a model referenced by a Model block in accelerator mode.

For the first condition, use accelerator mode.

For the second condition, use normal or rapid accelerator mode.

You cannot log the states of the blocks in a For Each subsystem .

Save and restore the simulation state (SimState).

You cannot use normal mode to simulate a Model block inside a For Each subsystem.

Use acclerator or rapid accelerator mode.

Reusable code is generated for two For Each Subsystems with identical contents if their input and output signals are vectors ( 1-D or 2-D row or column vector). For n-D input and output signals, reusable code is generated only when the dimension along which the signal is partitioned is the highest dimension.

Permute the signal dimensions to transform the partition dimension and the concatenation dimension to the highest nonsingleton dimension for n-D signals.

The For Each Subsystem block does not support the following features:

  • You cannot include the following blocks or S-functions inside a For Each Subsystem:

    • Data Store Memory, Data Store Read, or Data Store Write blocks inside the subsystem

    • The From Workspace block if the input is a Structure with Time that has an empty time field.

    • The To Workspace and To File data saving blocks

    • Goto and From blocks that cross the subsystem boundary.

    • Model Reference block with simulation mode set to 'Normal'

    • Shadow Inports

    • ERT S-functions

    For a complete list of the blocks that support the For Each Subsystem, type showblockdatatypetable at the MATLAB® command line.

  • You cannot use the following kinds of signals:

    • Test-pointed signals or signals with an external storage class inside the system

    • Frame signals on subsystem input and output boundaries

    • Variable-size signals

    • Function-call signals crossing the boundaries of the subsystem

  • Creation of a linearization point inside the subsystem

  • Propagating the Jacobian flag for the blocks inside the subsystem. You can check this condition in MATLAB using J.Mi.BlockAnalyticFlags.jacobian, where J is the Jacobian object. To verify the correctness of the Jacobian of the For Each Subsystem, perform the following steps

    • Look at the tag of the For Each Subsystem Jacobian. If it is "not_supported", then the Jacobian is incorrect.

    • Move each block out of the For Each Subsystem and calculate its Jacobian. If any block is "not_supported" or has a warning tag, the For Each Subsystem Jacobian is incorrect.

  • You cannot perform the following kinds of code generation:

    • Generation of a Simulink Coder S-function target

    • Simulink Coder code generation under both of the following conditions:

      • A Stateflow® or MATLAB Function block resides in the subsystem.

      • This block tries to access global data outside the subsystem, such as Data Store Memory blocks or Simulink.Signal objects of ExportedGlobal storage class.

    • PLC code generation

S-Function Support

The For Each Subsystem block supports both C-MEX S-functions and Level-2 MATLAB S-functions, provided that the S-function supports multiple execution instances using one of the following techniques:

  • A C-MEX S-function must declare ssSupportsMultipleExecInstances(S, true) in the mdlSetWorkWidths method.

  • A Level-2 MATLAB S-function must declare 'block.SupportsMultipleExecInstances = true' in the Setup method.

If you use the above specifications:

  • Do not cache run-time data, such as DWork and Block I/O, using global or persistent variables or within the userdata of the S-function.

  • Every S-function execution method from mdlStart up to mdlTerminate is called once for each element processed by the S-function, when it is in a For Each Subsystem. Consequently, you need to be careful not to free the same memory on repeated calls to mdlTerminate. For example, consider a C-MEX S-function that allocates memory for a run-time parameter within mdlSetWorkWidths. The memory only needs to be freed once in mdlTerminate. As a solution, set the pointer to be empty after the first call to mdlTerminate.

Data Type Support

The For Each Subsystem block accepts real or complex signals of the following data types:

  • Floating point

  • Built-in integer

  • Fixed point

  • Boolean

  • Non-virtual bus

  • Enumerated

For more information, see Data Types Supported by Simulink in the Simulink documentation.

Examples of Working with For Each Subsystems

Vectorize Algorithms Using For Each Subsystems

This example shows how to simplify modeling of vectorized algorithms. Using For Each subsystem blocks simplifies a model where three input signals are filtered by three identical Transfer Fcn blocks. This example also shows how to add more control to the filters by changing their coefficients for each iteration of the subsystem.

This model uses identical Transfer Fcn blocks to independently process each element of the input sine wave signal. A Vector Concatenate block concatenates the resulting output signals. This repetitive process is graphically complex and difficult to maintain. Also, adding another element to the signal requires significant reworking of the model.

You can simplify this model by replacing the repetitive operations with a single For Each Subsystem block.

The For Each subsystem contains a For Each block and a model representing the algorithm of the three blocks it replaces by way of the Transfer Fcn block. The For Each block specifies how to partition the input signal vector into individual elements and how to concatenate the processed signals to form the output signal vector. Every block that has a state maintains a separate set of states for each input element processed during a given execution step.

For this example, the input signal is selected for partitioning. The Partition Dimension and the Partition Width parameters on the For Each block are both set to 1 for the input.

You can scale up this approach to add more signals without having to change the model significantly. This approach is considered easily scalable and graphically simpler.

Model Parameter Variation Without Changing Model Structure

This example shows how to model parameter variation in an algorithm. It uses the For Each Subsystem partitioning model from Vectorize Algorithms Using For Each Subsystems and creates different filters for each input signal while retaining model simplicity. You do this by feeding an array of filter coefficients to the For Each subsystem as a mask parameter marked for partitioning. In each iteration of the For Each subsystem, a partition of the filter coefficients is fed to the Transfer Fcn block.

  1. Open the model ex_ForEachSubsystem_Partitioning. Create a mask for the For Each Subsystem block and add an editable mask parameter. Set the name to FilterCoeffs and the prompt to Filter Coefficient Matrix. For information on how to add a mask parameter, see Create a Simple Mask.

  2. Open the For Each subsystem. Inside the subsystem, open the For Each block dialog box.

  3. In the Parameter Partition tab, select the check box next to the FilterCoeffs parameter to enable partitioning of this parameter. Keep the Partition Width and Partition Dimension parameters at their default value of 1.

  4. Double-click the For Each Subsystem block and enter your filter coefficient matrix, having one row of filter coefficients for each input signal. For example, enter [0.0284 0.2370 0.4692 0.2370 0.0284; -0.0651 0 0.8698 0 -0.0651; 0.0284 -0.2370 0.4692 -0.2370 0.0284] to implement different fourth-order filters for each input signal.

  5. In the For Each subsystem, double-click the Transfer Fcn block and enter FilterCoeffs for the Denominator Coefficients parameter. This setting causes the block to get its coefficients from the mask parameter.

The For Each subsystem slices the input parameter into horizontal partitions of width 1, which is equivalent to one row of coefficients. The parameter of coefficients transforms from a single array:

into three rows of parameters:

Improved Code Reuse Using For Each Subsystems

This example shows how you can improve code reuse when you have two or more identical For Each subsystems. Consider the following model, rtwdemo_foreachreuse.

The intent is for the three subsystems — Vector SS1, Vector SS2, and Vector SS3 — to apply the same processing to each scalar element of the vector signal at their respective inputs. Because these three subsystems perform the same processing, it is desirable for them to produce a single shared Output (and Update) function for all three subsystems in the code generated for this model. For example, the Vector SS3 subsystem contains the following blocks:

To generate a single shared function for the three subsystems, the configuration of the partitioning they perform on their input signals must be the same. For Vector SS1 and Vector SS3, this configuration is straightforward because you can set the partition dimension and width to 1. However, in order for Vector SS2 to also partition its input signal along dimension 1, you must insert a Math Function block to transpose the 1-by-8 row vector into an 8-by-1 column vector. You can then convert the output of the subsystem back to a 1-by-8 row vector using a second Math Function block set to the transpose operator.

If you press Ctrl+B to generate code, the resulting code uses a single Output function. This function is shared by all three For Each Subsystem instances.

 * Output and update for iterator system:
 *    '<Root>/Vector SS1'
 *    '<Root>/Vector SS2'
 *    '<Root>/Vector SS3'
void VectorProcessing(int32_T NumIters, const real_T rtu_In1[], 
                      real_T rty_Out1[],
                      rtDW_VectorProcessing *localDW)

The function has an input parameter NumIters that indicates the number of independent scalars that each For Each Subsystem is to processes. This function is called three times with the parameter NumIters set to 10, 8, and 7 respectively.

The remaining two subsystems in this model show how reusable code can also be generated for matrix signals that are processed using the For Each Subsystem block. Again, pressing Ctrl+B to generate the code provides code reuse of a single function.


Data Types

Double | Single | Boolean | Base Integer | Fixed-Point | Enumerated | Bus

Sample Time

Inherited from driving block

Multidimensional Signals


Variable-Size Signals


Code Generation


Introduced in R2010a

Was this topic helpful?