Unexpected Perturbation of Constant Inputs During Full-System Linearization

I am working with a fully functional, complex dynamic system model in Simulink, structured into three main subsystems, each of which contains many nested subsystems. My objective is to linearize the entire system, so I define input and output analysis points at the root level in order to obtain a full-system linear model.

However, I am encountering unexpected behavior during linearization related to constant signals used within the subsystems.

In particular, some of the internal subsystems contain MATLAB Function blocks that receive constant values as inputs. These constants are used inside the functions to implement simple switching logic depending on the current configuration. During standard simulation, this setup works correctly. However, during linearization — even though these constants are not exposed as root-level inputs — they appear to be perturbed by the linearization process. This causes the switching logic to fail and results in errors within the MATLAB Function blocks.

A similar issue occurs in masked subsystems connected to a library. Some constants are defined as mask parameters and passed as inputs to MATLAB Function blocks inside the masked subsystem. These constants also seem to be perturbed during linearization, which again leads to incorrect behavior inside the functions.

To further investigate, I tried linearizing one of the top-level subsystems independently (still defining input and output points at the root level), and the same problem occurred. I also extracted one of the problematic internal subsystems and inserted it into a very simple test model, and the issue persisted there as well — confirming that the behavior is not specific to the complexity of the full model.

I would appreciate clarification on how the linearization engine handles such constant signals, especially when they are not explicitly set as tunable parameters or external inputs. Is there a recommended way to prevent these constants from being perturbed during the linearization process?

Thank you in advance for your support.

Answer 1

[Paul]

Hi Gabriele,

I wasn't able to create a simple model to replicate the problem, so I can't say for sure that what follows is 100% accurate.

Assuming you're using the default, "blockbyblock", linearization, the linearizer will try to linearize the MATLAB Function block by perturbing the inputs to the block and computing the resulting perturbation to the output. At this point, the linearizer doesn't know that an input is connected to a Constant block. So it goes ahead and perturbs the associated input to the block and proceeds, which is basically what you've stated.

See Exact Linearization Algorithm for discussion.

Options for solution (there may be others?):

Instead of using a Constant block as input to the Matlab Function, make the constant a parameter to the function so it's not an input. Use Data in Multiple MATLAB Function Blocks by Defining Parameter Variables

Try setting the perturbation level to zero for the input that comes from Constant block: Change Perturbation Level of Blocks Perturbed During Linearization. I confess that I don't fully understand how this works, but it worked for me in a simple case.

If you know what the linearization should be for the Matlab Function block, you can specify it directly: Specify Individual Block Linearization

The nuclear option would be to change the linearization method from blockbyblock to one of the numerical perturbation options (which should be applicable in this case because you're linearizing from root inputs to root outputs): linearizeOptions

More generally check: Identify and Fix Common Linearization Issues and other related doc pages.

[Paul]

I'm trying to verify some of the answer above, but getting confusing results so far ...

Try as I might, I can't come up with a simple example where the MATLAB Function linearizes differently depending on how a Constant input is used within the function.

[Gabriele]

Hi Paul,

Thanks again for the follow-up — and I wanted to clarify some additional important points that might help better frame the issue.

In my case, the MATLAB Function block in question is reused in multiple subsystems, but each subsystem provides a different constant (e.g., 1, 2, 3, 4) to the function. This constant is used internally to select a specific logic path (via switch or if-else). Therefore, I cannot simply pass this constant as a parameter to the function, because each instance must receive a different value. Using a global parameter would break this modular behavior.

Also, I want to stress that the problem is not that the MATLAB Function block is being linearized incorrectly. The real issue is that during linearization, these constants are perturbed, and as a result they lose their integer values — becoming something like 1.00001 or 0.9999. This breaks the internal switching logic, which relies on exact integer comparisons. So the function fails not due to bad linearization, but because it's operating in an invalid state due to perturbation.

I also tried using numerical perturbation (instead of block-by-block analytic), and unfortunately the behavior remains the same — the constants are still perturbed. So it doesn’t seem to be a method-specific issue.

My main question is:

Is it correct that the linearization engine perturbs constant signals like these — even when they are defined as fixed constant blocks or mask parameters? Shouldn’t there be a way to flag them as "non-perturbable"? These are discrete, structural constants that determine configuration — not continuous parameters that affect dynamics.

Let me know if there's any guidance or best practice to handle this kind of situation properly during linearization, especially when reusing functions with different internal logic across subsystems.

Thanks again for your time and help!

Best regards,

Gabriele

[Paul]

"Is it correct that the linearization engine perturbs constant signals like these — even when they are defined as fixed constant blocks or mask parameters? Shouldn’t there be a way to flag them as "non-perturbable"?

I don't think the linearization engine is perturbing the Constant. Rather, it's perturbing the input signal to the MATLAB Function block, in isolation, w/o knowing that input is actually connected to a Constant block.

Consider this simple model:

bdclose('all');
hsys = new_system('lintest');
hconstant = add_block('simulink/Sources/Constant','lintest/Constant');
hinput    = add_block('simulink/Sources/In1','lintest/u');
hfunc     = add_block('simulink/User-Defined Functions/MATLAB Function','lintest/func');
hout      = add_block('simulink/Sinks/Out1','lintest/y');

mfc = get_param(hfunc,'MatlabFunctionConfiguration');
functionscript = [
    "function y = fcn(u1,u2)";
    "u2";
    "if u2 == 1";
    "y = 10*u1;";
    "else";
    "y = 100*u1;";
    "end";
    "end"];
mfc.FunctionScript = join(functionscript,newline);

add_line(hsys,get_param(hinput,'PortHandles').Outport, ...
              get_param(hfunc,'PortHandles').Inport(1));
add_line(hsys,get_param(hconstant,'PortHandles').Outport,...
              get_param(hfunc,'PortHandles').Inport(2));
add_line(hsys,get_param(hfunc,'PortHandles').Outport,...
              get_param(hout,'PortHandles').Inport);

% command to open the model on the canvas
% open_system('lintest');

format long e
format compact

The PerturbationForJacobian parameter, as I understand it, is supposed to give us control over how much an input signal to a block is perturbed when the Jacobian wrt to the input is formed numerically.

set_param(get_param('lintest/func','PortHandles').Inport(2),'PerturbationForJacobian','1e-5');
sys = linearize('lintest',[linio('lintest/u',1,'input'),linio('lintest/func',1,'output')])

u2 =
     1
u2 =
     1
u2 =
     1
u2 =
     1.000020000000000e+00
u2 =
     9.999800000000000e-01

sys =
 
  D = 
          u
   func  10
 
Static gain.

With the default block-by-block linearization we see that the Matlab Function is executed five times. I presume the first is get the nominal output, the next two are perturbations to the first input, and the last two are perturbations to the second input, where two perturbations are used for each input to estimate the elements of the Jacobian via central difference. As expected, and as you noted, the second input, which is connected to the Constant, is perturbed, and the pertubation is 1e-5*(1 + k0), where k0 is the value of the second input at the operating point, i.e., k0 = 1. Hence the perturbation is 1e-5*(1 + 1) = 2e-5, exactly as we see. Note also that 1e-5 is the default, but I set it here explicitly.

However, something odd occurs if we try to make the perturbation larger

set_param(get_param('lintest/func','PortHandles').Inport(2),'PerturbationForJacobian','1e-3');
sys = linearize('lintest',[linio('lintest/u',1,'input'),linio('lintest/func',1,'output')])

u2 =
     1
u2 =
     1
u2 =
     1
u2 =
     1.000020000000000e+00
u2 =
     9.999800000000000e-01

sys =
 
  D = 
          u
   func  10
 
Static gain.

or smaller

set_param(get_param('lintest/func','PortHandles').Inport(2),'PerturbationForJacobian','1e-7');
sys = linearize('lintest',[linio('lintest/u',1,'input'),linio('lintest/func',1,'output')])

u2 =
     1
u2 =
     1
u2 =
     1
u2 =
     1.000020000000000e+00
u2 =
     9.999800000000000e-01

sys =
 
  D = 
          u
   func  10
 
Static gain.

In all cases, we get the same perturbation to that second input during the linearization process. Maybe that's a bug?

My hope was that setting the perturbation to 0 would mitigate your problem

set_param(get_param('lintest/func','PortHandles').Inport(2),'PerturbationForJacobian','0');
sys = linearize('lintest',[linio('lintest/u',1,'input'),linio('lintest/func',1,'output')])

u2 =
     1
u2 =
     1
u2 =
     1
u2 =
     1.000020000000000e+00
u2 =
     9.999800000000000e-01

sys =
 
  D = 
          u
   func  10
 
Static gain.

but, as not expected, doing so has no effect. I was actually wondering what would happen in this case because forming a Jacobian with a zero perturbation should result in a divide-by-zero unless the algorithm catches that as a special case, but obviously there is something else happening here.

At this point, I'd like to point out that even though the algorithm is, or at least seems to be, computing a 1x2 Jacobian for the Matlab Function block, the second element of that Jacobian is ultimately not used because the Constant block is not a variable input to the system. So I can understand how the second input signal loses its integer value in portions of the linearization process that compute the derivative wrt to that second signal, but I'm still not able to envision how that can affect the elements of the Jacobian wrt to the other input signals to the block, which are the only elements that matter (assuming they're connected to varying inputs). I'd be very interested if you have a minimum, working example, that illustrates that behavior.

"I also tried using numerical perturbation (instead of block-by-block analytic), and unfortunately the behavior remains the same — the constants are still perturbed."

Trying the numerical perturbation algorithm seems to work here, at least in the sense that there is no evidence that the second input to the Matlab Function block is being perturbed

sys = linearize('lintest',linearizeOptions('LinearizationAlgorithm','numericalpert'))

u2 =
     1
u2 =
     1
u2 =
     1

sys =
 
  D = 
               u
   lintest/y  10
 
Static gain.

though I am surprised that the block executes three times. I was expecting it to execute twice for a forward difference approximation.

[Paul]

If we set the data type of the Constant block that feeds the MATLAB Function to an integer, the linearizer does not perturb it from its constant value. That seems to be exactly the desired behavior.

bdclose('all');
hsys = new_system('lintest');
hconstant = add_block('simulink/Sources/Constant','lintest/Constant');
hinput    = add_block('simulink/Sources/In1','lintest/u');
hfunc     = add_block('simulink/User-Defined Functions/MATLAB Function','lintest/func');
hout      = add_block('simulink/Sinks/Out1','lintest/y');
mfc = get_param(hfunc,'MatlabFunctionConfiguration');
functionscript = [
    "function y = fcn(u1,u2)";
    "u2";
    "if u2 == 1";
    "y = 10*u1;";
    "else";
    "y = 100*u1;";
    "end";
    "end"];
mfc.FunctionScript = join(functionscript,newline);
add_line(hsys,get_param(hinput,'PortHandles').Outport, ...
              get_param(hfunc,'PortHandles').Inport(1));
add_line(hsys,get_param(hconstant,'PortHandles').Outport,...
              get_param(hfunc,'PortHandles').Inport(2));
add_line(hsys,get_param(hfunc,'PortHandles').Outport,...
              get_param(hout,'PortHandles').Inport);
% command to open the model on the canvas
% open_system('lintest');

set_param(hconstant,'OutDataTypeStr','int32')

format long e
format compact
set_param(get_param('lintest/func','PortHandles').Inport(2),'PerturbationForJacobian','1e-5');
sys = linearize('lintest',[linio('lintest/u',1,'input'),linio('lintest/func',1,'output')])

u2 =
   1
u2 =
   1
u2 =
   1
u2 =
   1
u2 =
   1

sys =
 
  D = 
          u
   func  10
 
Static gain.

[Gabriele]

The problem is that for some kind of function then that constant must be double so then I have another problem.

I have some project where this is clear but I think that using a simulink model and the model linearizer is a little different but the behaviours seems to be the same how can we discuss on that?

[Paul]

If the output of the Constant block must be double for some other reason, then you can add a Data Type Conversion block between the Constant and the Matlab Function so that it sees an int, but all other users of the Constant block see a double.

bdclose('all');
hsys = new_system('lintest');
hconstant = add_block('simulink/Sources/Constant','lintest/Constant');

hdtc      = add_block('simulink/Signal Attributes/Data Type Conversion','lintest/dtc');
set_param(hdtc,'OutDataTypeStr','int32');

hinput    = add_block('simulink/Sources/In1','lintest/u');
hfunc     = add_block('simulink/User-Defined Functions/MATLAB Function','lintest/func');
hout      = add_block('simulink/Sinks/Out1','lintest/y');

mfc = get_param(hfunc,'MatlabFunctionConfiguration');
functionscript = [
    "function y = fcn(u1,u2)";
    "u2";
    "if u2 == 1";
    "y = 10*u1;";
    "else";
    "y = 100*u1;";
    "end";
    "end"];
mfc.FunctionScript = join(functionscript,newline);

add_line(hsys,get_param(hinput,'PortHandles').Outport, ...
              get_param(hfunc,'PortHandles').Inport(1));


add_line(hsys,get_param(hconstant,'PortHandles').Outport,...
              get_param(hdtc,'PortHandles').Inport);
add_line(hsys,get_param(hdtc,'PortHandles').Outport,...
              get_param(hfunc,'PortHandles').Inport(2));


add_line(hsys,get_param(hfunc,'PortHandles').Outport,...
              get_param(hout,'PortHandles').Inport);
% command to open the model on the canvas
% open_system('lintest');

format long e
format compact
set_param(get_param('lintest/func','PortHandles').Inport(2),'PerturbationForJacobian','1e-5');
sys = linearize('lintest',[linio('lintest/u',1,'input'),linio('lintest/func',1,'output')])

u2 =
   1
u2 =
   1
u2 =
   1
u2 =
   1
u2 =
   1

sys =
 
  D = 
          u
   func  10
 
Static gain.

"I have some project where this is clear but I think that using a simulink model and the model linearizer is a little different but the behaviours seems to be the same how can we discuss on that?"

I'm afraid I don't understand this question. Is it related to the present discussion? If not, consider opening up a new Question.

[Paul]

Regarding the bevior shown in this comment where PerturbationForJacobian had no effect ...

Tech Support confirmed a bug when using that parameter with a Matlab Function block.

Answer 2

[Gabriele]

Is there any way to use the Model Linearizer in Simulink so that, even when the system is complex or an error occurs during the linearization process, MATLAB and Simulink do not crash or close unexpectedly without showing any error message?

I’ve already tried enabling the Linearization Advisor, but unfortunately it doesn’t make any difference—the issue still occurs, and the software shuts down abruptly without providing any diagnostic information.

[Paul]

That sounds like a question for Mathworks tech support.

Answer 3

[Gabriele]

Hi my other issue always in the model is the error exceeding breaking point for the lookup Table even if there is the clip as algorithm for extraction and if i change advise from error to warning than it only crushes

[Paul]

Crashes should be worked with Mathworks tech support.

[Gabriele]

Yes I know but I was wondering if there is another solution, because the only one that I found is to change from error to warning and I am not 100% sure of this. So i was wandering if there is another slution to linearize a lookup table

Answer 4

[Gabriele]

Hi paul. Can i ask you if it is possible to linearize a lookuptable by clicking right on it and then linear analysis-->specify selected block linearization. How should I code the function to linearize a lookuptable which uses Clip as extrapolation method and it uses last table value for inputs at or above last breakpoints? Because i found hard to develop it.

[Paul]

Seems like the configuration function with the BlockData input should allow you to implement whatever you want, but I haven't actually tried anything. Presumably if the independent variable is not outside the breakpoints then the function would resturn the slope of the data, and return 0 otherwise (though I guess you'd have to make a decision about the case when the input is exactly on a breakpoint).