Simulink.Solver.FixedStepSolver Class

R2026b

Namespace: Simulink.Solver

Write fixed-step plugin solver for Simulink simulation

Since R2026b

Description

Simulink.Solver.FixedStepSolver is the base class for authoring fixed-step plugin solvers. Simulink^® provides several built-in solvers that can simulate a wide range of systems. However, the built-in solver integration algorithms are not necessarily ideal for all domains and problems. Using the plugin solver interface, you can implement custom solver integration algorithms for Simulink simulations.

At each time step in the simulation, a fixed-step solver:

Integrates continuous states by solving an initial value problem (IVP).
In the first time step, the initial state defines the initial value for the IVP. The solver computes the state at the next time step, which becomes the initial value in the next time step.
Advances time using a fixed step size.
The Fixed-step size (fundamental sample time) configuration parameter of the simulated system defines the step size.

To write a plugin solver, you define only the integration algorithm in the step method. The Simulink environment provides solver services, such as zero-crossing detection. For more information about Simulink solvers, see Choose a Solver.

To simulate a system using a plugin solver:

Save the class definition for the plugin solver in a location on the MATLAB^® path or add the plugin solver location to the path.
Register the plugin solver using the Simulink.Solver.register function.
Specify the Solver parameter as the name of the plugin solver.

To implement a variable-step plugin solver, use the Simulink.Solver.VariableStepSolver class.

The Simulink.Solver.FixedStepSolver class is a handle class.

Class Attributes

Abstract true

For information on class attributes, see Class Attributes.

Properties

expand all

`NumStates` — Number of continuous states in simulated system
positive scalar integer

Number of continuous states in simulated system, returned as a positive scalar integer. This property is available only during simulation.

The number of states in the simulated system determines the size of the state and state derivative input and output arguments for the step, forcingFunction, Jacobian, massMatrix, interpolateState, and reset methods.

Attributes:

`GetAccess`	`public`
`SetAccess`	`private`
`Dependent`	`true`

Data Types: double

Methods

expand all

Public Methods

`step`	`xout = step(slvr,t0,x0,h)` Integrate continuous states to next time step. The `step` method is abstract. The implementation defines the plugin solver integration algorithm. To compute continuous states in the simulated system, the simulation calls the `step` method in each time step. Input arguments: `slvr` — Plugin solver instance `t0` — Simulation time for current time step `x0` — Continuous state values in current time step `h` — Fixed step size The `step` method returns the continuous state values `xout` computed for the next time step.
`forcingFunction`	`f = forcingFunction(slvr,t,x)` Evaluate forcing function. To evaluate derivatives of continuous states in the simulated system, call this method in the implementation of the `step` method. The `forcingFunction` method is sealed. Input arguments: `slvr` — Plugin solver instance `t` — Time at which to evaluate continuous state derivatives `x` — Continuous state values at time `t` The `forcingFunction` method returns the right-hand side of the forcing function equation $M (t, x) * \dot{x} = f (t, x),$ where: M(t,x) is the mass matrix evaluated at time t with state values x. $\dot{x}$ is a vector of the continuous state derivatives. f(t,x) is the forcing function evaluated at time t with state values x. If the system is explicit, the mass matrix is an identity matrix and the method returns the continuous state derivatives.
`Jacobian`	`J = Jacobian(slvr,t,x)` Evaluate Jacobian of simulated system. If the integration algorithm requires the system Jacobian, call this method in the implementation of the `step` method. The `Jacobian` method is sealed. Input arguments: `slvr` — Plugin solver instance `t` — Time at which to evaluate Jacobian `x` — Continuous state values at time `t` The `Jacobian` method returns the system Jacobian matrix `J`, evaluated at time `t` with continuous state values `x`. To enable support for this method, the `getProperties` method must specify `Jacobian` as `true`.
`massMatrix`	`M = massMatrix(slvr,t,x)` Evaluate mass Matrix of simulated system. If the integration method uses the mass matrix, call this method in the implementation of the `step` method. The `massMatrix` method is sealed. Input arguments: `slvr` — Plugin solver instance `t` — Time at which to evaluate mass matrix `x` — Continuous state values at time `t` The `massMatrix` method returns the mass matrix `M`, evaluated at time `t` with state values `x`. The requirements for evaluating the mass matrix in the integration algorithm depend on the nature of the mass matrix in the simulated system. For example, if the mass matrix is constant, the solver can evaluate the mass matrix once, at the start of the simulation. To speed up solver execution during simulation, evaluate the mass matrix only when necessary. To enable support for this method, the `getProperties` method must specify `MassMatrix` as `true`.
`isStateDependentMassMatrix`	`tf = isStateDependentMassMatrix(slvr)` Returns `true` if the mass matrix of the simulated system depends on both time and state. To enable support for this method, specify `MassMatrix` as `true` in the `getProperties` method.
`isTimeDependentMassMatrix`	`tf = isTimeDependentMassMatrix(slvr)` Returns `true` if the mass matrix of the simulated system depends only on time. To enable support for this method, specify `MassMatrix` as `true` in the `getProperties` method.
`isConstantMassMatrix`	`tf = isConstantMassMatrix(slvr)` Returns `true` if the mass matrix of the simulated system is constant. To enable support for this method, specify `MassMatrix` as `true` in the `getProperties` method.
`isIdentityMassMatrix`	`tf = isIdentityMassMatrix(slvr)` Returns `true` if the mass matrix of the simulated system is the identity matrix. To enable support for this method, specify `MassMatrix` as `true` in the `getProperties` method.
`interpolateState`	`xi = interpolateState(slvr,ti,tleft,tright,xleft,xright)` Approximate continuous state values in minor time steps. Some solver services interpolate continuous state values in minor time steps. For example, the zero-crossing detection algorithm interpolates continuous states when locating the time of a zero crossing. By default, the `interpolateState` method provides a linear interpolation algorithm. To provide a more sophisticated interpolation scheme, implement this method. Input arguments: `slvr` — Plugin solver instance `ti` — Time at which to interpolate state values `tleft` — Time with known state values prior to `ti` `tright` — Time with known state values after `ti` `xleft` — State values at time `tleft` `xright` — State values at time `xleft` The `interpolateState` vector returns the interpolated state values as the vector `xi`.
`getProperties`	`props = getProperties(slvr)` Define properties of plugin solver. The `getProperties` method provides information about the plugin solver to the Simulink environment. The method returns the solver properties as the structure `props`. The structure contains these fields: `MassMatrix` — Mass matrix requirement, specified as `true` or `false` `DAE` — Differential-algebraic equation support, specified as `true` or `false` `Jacobian` — Solver Jacobian requirement, specified as `true` or `false` `description` — Description of plugin solver By default, the `getProperties` method specifies all solver properties as `false`.
`start`	`start(slvr)` Initialize solver. At the start of a simulation, the simulator initializes the solver by calling this method. Implement this method if the solver has unique requirements for initializing states or data structures. The simulator calls the `start` method only in the first simulation run after enabling fast restart. To reinitialize the solver between simulations, implement the `stop` method.
`stop`	`stop(slvr)` Reinitialize solver between fast restart simulations. The simulator calls this method at the end of each fast restart simulation. Implement this method if you implement the `start` method.
`reset`	`reset(slvr,t0,x0,dx0)` Reinitialize solver when solver reset occurs during simulation. The simulator resets the solver when solver events, such as zero-crossing events, occur during simulation. To reset information stored in the solver, such as cached derivative evaluations or state history, implement this method. Input arguments: `slvr` — Instance of plugin solver `t0` — Time of solver reset `x0` — Continuous state values at `t0` `dx0` — Continuous state derivatives at `t0`

Examples

collapse all

Simulate Model Using Fixed-Step Backward Euler Plugin Solver

Write a class that defines a fixed-step backward Euler plugin solver. Then, register the plugin solver and simulate a model.

The class BackwardEuler defines the solver properties and integration algorithm of a fixed-step backward Euler solver. The property NewtonIterations defined in the class stores the number of Newton's iterations the integration algorithm performs. The getProperties method creates and returns a structure that specifies these solver properties:

DAE — The solver supports solving systems of differential-algebraic equations.
MassMatrix — The integration algorithm is implicit and uses the mass matrix of the simulated system.
Jacobian — The integration algorithm uses the Jacobian.

The integration algorithm defined in the step method:

Advances time by computing t1, the time of the next time step
Computes the Jacobian and mass matrix for the current time step by calling the Jacobian and massMatrix methods
Iteratively computes the state values in the next time step x1
Recomputes the mass matrix in each iteration if the mass matrix depends on the state values

classdef BackwardEuler < Simulink.Solver.FixedStepSolver
    properties
        NewtonIterations = 3;
    end

    methods (Static)
        function props = getProperties
            props = struct("MassMatrix",true,"DAE",true,"Jacobian",true);
        end
    end
    
    methods
        function x1 = step(slvr,t0,x0,h)
            t1 = t0 + h;
            J = slvr.Jacobian(t0,x0);
            M = slvr.massMatrix(t0,x0);
            W = M - h * J;

            x1 = x0;
            z = zeros(size(x0));

            for n = 1:slvr.NewtonIterations
                if slvr.isStateDependentMassMatrix && n > 1
                    M = slvr.massMatrix(t1,x1);
                end
                g = h * slvr.forcingFunction(t1,x1) - M * z;
                dg = W \ g;
                x1 = x1 + dg;
                z = z + dg;
            end
        end
    end
end

To simulate a system using the plugin solver, register the solver. Then, specify the SolverType and Solver configuration parameters in the system. For example, this code registers the plugin solver ODE12 and then uses the solver to simulate the system MyModel.

mdl = "MyModel";
Simulink.Solver.register("BackwardEuler")
set_param(mdl,SolverType="Fixed-step")
set_param(mdl,Solver="BackwardEuler")
out = sim(mdl);

Limitations

Plugin solvers do not support:

Rapid accelerator simulation
Software-in-the-loop (SIL) and processor-in-the-loop (PIL) simulation
Deployment with Simulink Compiler™
Production code generation using Simulink Coder™ or Embedded Coder^®

Version History

Introduced in R2026b

Simulink.Solver.FixedStepSolver Class

Description

Class Attributes

Properties

`NumStates` — Number of continuous states in simulated system
positive scalar integer

Attributes:

Methods

Public Methods

Examples

Simulate Model Using Fixed-Step Backward Euler Plugin Solver

Limitations

Version History

See Also

Classes

Functions

Topics

Simulink.Solver.FixedStepSolver Class

Description

Class Attributes

Properties

NumStates — Number of continuous states in simulated system positive scalar integer

Attributes:

Methods

Public Methods

Examples

Simulate Model Using Fixed-Step Backward Euler Plugin Solver

Limitations

Version History

See Also

Classes

Functions

Topics

`NumStates` — Number of continuous states in simulated system
positive scalar integer