Function 使用相同的输入返回不同的结果

Question

I'm working on a modeling function to model the motion of a train. In my script, I have a check that runs a function three times. The second and third time it returns the same values, however on the first time, it returns different values.

    dvdtA = lambda x, v: (1 / (Tmass + mw)) * (Ap * (rg / rw)) * (((P0gauge + Patm) * V0) / (V0 + (Ap * (rg / rw) * x)) - Patm) \
        -0.5 * Cd * pa * A * (v**2) - (Cr * Tmass * g)

    dvdtD = lambda v: (1 / Tmass) * (- 0.5 * Cd * pa * A * (v**2) - (Cr * Tmass * g))
    dxdt = lambda v: v
    Ft = lambda x: (1 / (Tmass + mw)) * (Ap * (rg / rw)) * (((P0gauge + Patm) * V0) / (V0 + (Ap * (rg / rw) * x)) - Patm)
    trainMotion = np.array([dvdtA, dvdtD, dxdt, Ft])

    # Checking design constraints ######################################
    if (Ht < 0.23) and (Wt < 0.2) and (rg/rw < 1):

        # Optimization #################################################
        if RK4(trainMotion, h, tspan, v0, x0, La, slipCheck) is not None:
            if RK4(trainMotion, h, tspan, v0, x0, La, slipCheck)[1] < tFinish:
                bestParams = np.array([r0, P0gauge, rg, Ls, rp, tankMat])
                bestODE = trainMotion
                bestLa = La
                bestSlipCheck = slipCheck
                bestTime = RK4(trainMotion, h, tspan, v0, x0, La, slipCheck)[1]

This is written inside a for loop that randomly selects a set of parameters then runs them through to generate the ODES you see at the beginning. The error is happening underneath the "Optimization" area. The first call on RK4 generates a different set of results than the second and third, which both generate the exact same results. I can't figure out why the first time is different than the second and third. Furthermore, when I plug those "best[ODE/LA/etc] into the RK4 function again later on in the script, it fails the checks and returns None despite those parameters having passed the checks earlier.

For reference, here's the RK4 function itself:

import math as mt
import numpy as np

def RungeKutta(fun, h, tspan, x0, y0, Ls, slipCheck):
    yArr = np.zeros([len(tspan), 2])
    yArr[0,1] = y0
    yArr[0,0] = x0
    
    for i in range(len(tspan) - 1):
        
        k1 = fun[2](yArr[i, 1])
        k2 = fun[2](yArr[i, 1] + k1 * (h/2))
        k3 = fun[2](yArr[i, 1] + k2 * (h/2))
        k4 = fun[2](yArr[i, 1] + k3 * h)

        yArr[i+1, 0] = yArr[i, 0] + h * (k1/6 + k2/3 + k3/3 + k4/6)
        
        if (fun[3](yArr[i+1, 0]) > slipCheck) or (yArr[i+1, 0] > 12.5):
            return None

        if yArr[i, 0] <= Ls:
            k1 = fun[0](yArr[i, 0], yArr[i, 1])
            k2 = fun[0](yArr[i, 0] + h/2, yArr[i, 1] + k1 * (h/2))
            k3 = fun[0](yArr[i, 0] + h/2, yArr[i, 1] + k2 * (h/2))
            k4 = fun[0](yArr[i, 0] + h, yArr[i, 1] + k3 * h)

            yArr[i+1, 1] = yArr[i, 1] + h * (k1/6 + k2/3 + k3/3 + k4/6)

        elif yArr[i, 0] > Ls:
            k1 = fun[1](yArr[i, 1])
            k2 = fun[1](yArr[i, 1] + k1 * (h/2))
            k3 = fun[1](yArr[i, 1] + k2 * (h/2))
            k4 = fun[1](yArr[i, 1] + k3 * h)
                   
            yArr[i+1, 1] = yArr[i, 1] + h * (k1/6 + k2/3 + k3/3 + k4/6)

        if i >= 3:
            if yArr[i+1, 1] < 0 and yArr[i+1, 0] > 10:
                tFinish = tspan[i]
                data = np.column_stack((yArr, tspan))
                return data, tFinish       

    return None

Answer 1

Let RK4 always return 2 values, unpack the values when calling RK4

    dvdtA = lambda x, v: (1 / (Tmass + mw)) * (Ap * (rg / rw)) * (((P0gauge + Patm) * V0) / (V0 + (Ap * (rg / rw) * x)) - Patm) \
        -0.5 * Cd * pa * A * (v**2) - (Cr * Tmass * g)

    dvdtD = lambda v: (1 / Tmass) * (- 0.5 * Cd * pa * A * (v**2) - (Cr * Tmass * g))
    dxdt = lambda v: v
    Ft = lambda x: (1 / (Tmass + mw)) * (Ap * (rg / rw)) * (((P0gauge + Patm) * V0) / (V0 + (Ap * (rg / rw) * x)) - Patm)
    trainMotion = np.array([dvdtA, dvdtD, dxdt, Ft])

    # Checking design constraints ######################################
    if (Ht < 0.23) and (Wt < 0.2) and (rg/rw < 1):

        # Optimization #################################################
        data, tFinishResult = RK4(trainMotion, h, tspan, v0, x0, La, slipCheck)
        if data is not None:
            if tFinishResult < tFinish:
                bestParams = np.array([r0, P0gauge, rg, Ls, rp, tankMat])
                bestODE = trainMotion
                bestLa = La
                bestSlipCheck = slipCheck
                bestTime = tFinishResult

The RK4 function:

import math as mt
import numpy as np

def RungeKutta(fun, h, tspan, x0, y0, Ls, slipCheck):
    yArr = np.zeros([len(tspan), 2])
    yArr[0,1] = y0
    yArr[0,0] = x0
    
    for i in range(len(tspan) - 1):
        
        k1 = fun[2](yArr[i, 1])
        k2 = fun[2](yArr[i, 1] + k1 * (h/2))
        k3 = fun[2](yArr[i, 1] + k2 * (h/2))
        k4 = fun[2](yArr[i, 1] + k3 * h)

        yArr[i+1, 0] = yArr[i, 0] + h * (k1/6 + k2/3 + k3/3 + k4/6)
        
        if (fun[3](yArr[i+1, 0]) > slipCheck) or (yArr[i+1, 0] > 12.5):
            return None,None

        if yArr[i, 0] <= Ls:
            k1 = fun[0](yArr[i, 0], yArr[i, 1])
            k2 = fun[0](yArr[i, 0] + h/2, yArr[i, 1] + k1 * (h/2))
            k3 = fun[0](yArr[i, 0] + h/2, yArr[i, 1] + k2 * (h/2))
            k4 = fun[0](yArr[i, 0] + h, yArr[i, 1] + k3 * h)

            yArr[i+1, 1] = yArr[i, 1] + h * (k1/6 + k2/3 + k3/3 + k4/6)

        elif yArr[i, 0] > Ls:
            k1 = fun[1](yArr[i, 1])
            k2 = fun[1](yArr[i, 1] + k1 * (h/2))
            k3 = fun[1](yArr[i, 1] + k2 * (h/2))
            k4 = fun[1](yArr[i, 1] + k3 * h)
                   
            yArr[i+1, 1] = yArr[i, 1] + h * (k1/6 + k2/3 + k3/3 + k4/6)

        if i >= 3:
            if yArr[i+1, 1] < 0 and yArr[i+1, 0] > 10:
                data = np.column_stack((yArr, tspan))
                tFinish = tspan[i]
                return data, tFinish       

    return None, None