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

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

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 2

这最初是一个评论，但我没有了房间。

测试收敛到min的常用方法是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

Answer 3

你确定它们实际上正在收敛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)

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

3 个答案: