确定两个值的差值何时达到最小值

Question

下面的代码比较了值Cd和Cdd：

# use Python 3 print function and division
from __future__ import print_function
from __future__ import division

# libraries
import numpy as np

#--- INPUTS

rhog = 1.17     # density (kg/m^3)
ug = 1.85e-5    # dynamic viscosity (kg/ms)
g = 9.81        # gravity (m/s^2)

dp = 0.000207   # diameter of particle (m)
rhos = 2500     # density of particle (kg/m^3)
sp = 0.8        # sphericity of the particle, perfect sphere = 1.0 

#--- OUTPUTS

# acceptable difference between Cd and Cdd
dn = 0.02

# determine ut when abs(Cd-Cdd) is a minimum
for ut in np.arange(0, 20, 0.001):
    Re = (dp*rhog*ut)/ug
    Cd = (24/Re)*(1+(8.1716*np.exp(-4.0655*sp))*Re**(0.0964+0.5565*sp)) + (73.69*np.exp(-5.0748*sp)*Re)/(Re+5.378*np.exp(6.2122*sp))
    Cdd = (4*g*dp*(rhos-rhog))/(3*(ut**2)*rhog)
    delta = abs(Cd-Cdd)
    if delta < dn:
        break 

print('ut =', ut)
print('Re =', Re)
print('Cd =', Cd)
print('Cdd =', Cdd)
print('delta =', delta)

一切正常，除非代码是为sp的低值运行的，比如sp=0.2，这会导致delta < dn的条件永远不会出现。你知道吗

有没有更好的方法来比较Cd和Cdd术语？你知道吗

Answer 1

您确定它们实际上是为sp>0.2的值收敛吗？你确定当ut到达20时循环没有退出吗？我做了一些测试，将ut的值从0.0001循环到20，增量为1，sp从1循环到01，并在每次循环中打印值。它总是在ut==20处存在，Cd从不接近Cdd。。。你知道吗

spr = range(10,1,-1)
for spv in spr:
    sp = spv/10.0
# determine ut when abs(Cd-Cdd) is a minimum
    # for ut in np.arange(0, 20, 0.001):
    for ut in np.arange(0.0001, 20, 1):
        Re = (dp*rhog*ut)/ug
        Cd = (24/Re) * (1+(8.1716*np.exp(-4.0655*sp)) * Re**(0.0964+0.5565*sp)) + (73.69*np.exp(-5.0748*sp)*Re)/(Re+5.378*np.exp(6.2122*sp))

        # Cd2 = (24/Re) * (1 + 0.14*Re**0.7)  # for a sphere sp==1

        Cdd = (4*g*dp*(rhos-rhog))/(3*(ut**2)*rhog)
        delta = abs(Cd - Cdd)
        if delta < dn:
            continue 
        # print(sp,Cd,Cdd,Re,ut,delta)
        print(sp,ut,Cd,Cdd)

Answer 2

矢量化方法是计算所有值，然后寻找最小值：

ut = np.arange(0, 20, 0.001)
Re = (dp*rhog*ut)/ug
Cd = ((24/Re)*(1+(8.1716*np.exp(-4.0655*sp))*Re**(0.0964+0.5565*sp)) +
      73.69*np.exp(-5.0748*sp)*Re)/(Re+5.378*np.exp(6.2122*sp)))
Cdd = (4*g*dp*(rhos-rhog))/(3*(ut**2)*rhog)
delta = np.abs(Cd-Cdd)
idx = np.argmin(delta)

print('ut =', ut[idx])
print('Re =', Re[idx])
print('Cd =', Cd[idx])
print('Cdd =', Cdd[idx])
print('delta =', delta[idx])

因为没有Python循环，所以它可能比当前代码运行得更快，尽管它可能会做很多不必要的工作。你知道吗

Answer 3

这本来是一个评论，但我没有空间了。你知道吗

检验收敛到最小值的一种常用方法是RMSD（均方根偏差）检验。为了计算RMS偏差（也称为Standard Error），计算Cd和Cdd之间的平方差的平方根，即math.sqrt((Cd-Cdd)**2)每个间隔。然后，除以要比较的值的平方根（本例中为2）。你知道吗

这给了你：

rmsd = math.sqrt( ((Cd - Cdd)**2)/2 )

当两个值之间的差值收敛到最小值时，RMSD的变化将越来越小。最终它只会改变一小部分，你可以说差异已经收敛了。因此，在迭代之间跟踪rmsd，并对其应用delta：

if math.abs(rmsdPrior - rmsdCurrent) < delta:
    break