def METHOD_NAME(self, model, f, f2, stocks, arguments,
                                integration_frame, ts_log, ts_rmse):
    """
    Test the local truncation error (LTE).
    LTE = y_1 - y(t_0+h) = 0.5*h**2*y''(x) for x in [t_0, t_0+h]
    where y_1 = y(t_0) + h*f(t_0, y(t_0)) and
    Generates n_points_lte in the given integration frame and test the
    convergence with logarithmically uniform split time_steps.
    Parameter
    ---------
    model: pysd.py_backend.model.Model
        The model to integrate.
    f: tuple of functions
        The functions of the analytical solution of each stock.
    f2: tuple of functions
        The second derivative of the functions of the analytical
        solution of each stock.
    stocks: tuple of strings
        The name of the stocks.
    arguments: tuple of strings
        The neccessary argument names to evaluate f's and f2's.
        Note that all the functions must take the same arguments
        and in the same order.
    integration_frame: tuple
        Initial time of the model (usually 0) and maximum time to
        generate a value for test the LTE.
    ts_log: tuple
        log in base 10 of the inteval of time step to generate. I.e.,
        the first point will be evaluated with time_step = 10**ts_log[0]
        and the last one with 10**ts_log[1].
    ts_rmse: iterable
        Not used.
    """
    # Generate starting points to compute LTE
    t0s = np.random.uniform(*integration_frame, self.n_points_lte)
    # Generate time steps
    hs = 10**np.linspace(*ts_log, self.n_points_lte)
    # Get model values before making any change
    model_values = [model[var] for var in arguments]
    for t0, h in zip(t0s, hs):
        # Reload model
        model.reload()
        # Get start value(s)
        x0s = [
            func(t0, *model_values)
            for func in f
        ]
        # Get expected value(s)
        x_expect = np.array([
            func(t0 + h, *model_values)
            for func in f
        ])
        # Get error bound (error = 0.5h²*f''(x) for x in [t0, t0+h])
        # The 0.5 factor is removed to avoid problems with local maximums
        # We assume error < 2h²*max(f''(x)) for x in  [t0, t0+h]
        error = 2*h**2*np.array([
            max(func(np.linspace(t0, t0+h, 1000), *model_values))
            for func in f2
        ])
        # Run the model from (t0, x0s) to t0+h
        ic = t0, {stock: x0 for stock, x0 in zip(stocks, x0s)}
        x_euler = model.run(
            initial_condition=ic,
            time_step=h,
            return_columns=stocks,
            return_timestamps=t0+h
        ).values[0]
        # Expected error
        assert np.all(np.abs(x_expect - x_euler) <= np.abs(error)),\
            f"The LTE is bigger than the expected one ({ic}) h={h},"\
            f"\n{np.abs(x_expect - x_euler)} !<=  {np.abs(error)}, "