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:

1. Save the class definition for the plugin solver in a location on the MATLAB^® path or add the plugin solver location to the path.

2. Register the plugin solver using the Simulink.Solver.register function.

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

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

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

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