Python 迭代三个变量

好的，这将是非常长的时间。我试图用极坐标网格的解析解来计算水位。它取决于r和θ以及这个变量j。我要做的是，根据给定的方程式，计算网格中某个特定rθ点的水位。这个方程有一部分求和于j的无穷大值。等式的一部分在这里

部分守则如下：

"""
Plot idealized solution for water levels in a quarter circle domain with 
constant bathymetry  
"""
import numpy as np
import matplotlib.pyplot as plt
#from pylab import meshgrid,cm,imshow,contour,clabel,colorbar,axis,title,show

# establish parameters
Ho = 300 #m
g = 9.81 #m/s2
r1 = 1000 #m
r2 = 10000 #m
rr = np.arange(r1,r2,10)

#radial size of domain
phi = np.pi/2
#theta is the angle in radians at a specific location within the domain
#theta = np.pi/4

theta = np.arange(0, phi, np.pi/360)#varies
Theta = theta[1:180]

zeta = [0] * len(rr) * len(Theta)
#converting from wind speed to wind shear stress
U = 10
Cd = (1/1000) * ((3/4) + (U/15))
Roair = 1.225 #kg/m3
Rowater = 997 #kg/m3

W = (Roair/Rowater) * Cd * (U**2)

#wind shear in m^2/s^2 in the 0 direction (W to E)
Wo = np.sqrt((W**2)/2)
#wind shear in m^2/s^2 in the phi direction 
Wphi = np.sqrt((W**2)/2)

zeta = np.zeros((len(rr), len(Theta)))
#determines the bathymetry
a_star = []
n = 0
kappa = (1-n)**(0.5)
for t in range(len(Theta)):
    a_star.append ( ( (np.sin(phi)) / (g*Ho*kappa* np.sin(kappa*Theta[t])) ) )

#first half of equation 19 that does not depend on j 
for r in range(len(rr)):
    for t in range(len(Theta)):
        zeta[r,t] = ( (a_star[t] * (rr[r]**(1-n)))*(Wo*np.cos(((1-n)**(0.5))*Theta[t]) + Wphi*np.cos(((1-n)**(0.5))*(Theta[t]-phi))) )  

#second half of equation 19 for j=0    
ajbj = []

for t in range(len(Theta)):
    j = 0
    Djo = np.sin(( ( (1-n)**(0.5) ) * phi ) ) / ( (1-n)**(0.5) * (phi) ) 
    Ejo = (np.sin(phi)) / (phi) 
    ajbj.append (  (r2**(1-n)) * (-a_star[t] * Djo))
    for r in range(len(rr)):
        zeta[r,t] = zeta[r,t] + (ajbj[t])*(Wo+Wphi) 

#second half of equation 19 for j=1,2,3 (summation) 

sj = []
tj = []
Dj = []
Ej = []
r1EogH = []
astarD = []
tjr1r2 = []
sjr2 = []
aj = []
bj = []


jj = [1,2,3]
for j in range(len(jj)):
    sj.append(- (n/2) + np.sqrt( ( (n/2)**2) + ( (jj[j]*np.pi / phi)**2) ) )
    tj.append (- (n/2) - np.sqrt( ( (n/2)**2) + ( (jj[j]*np.pi / phi)**2) ) )    
    Dj.append ( (2* ((-1)**jj[j]) * ((1-n)**(0.5)) * phi * np.sin( ((1-n)**(0.5)) * phi )) / ( (1-n) * (phi**2) - (jj[j]**2) * (np.pi**2) ) )
    Ej.append ( (2* ((-1)**jj[j]) * phi * np.sin(phi) ) / ( (phi**2) - (jj[j]**2) * (np.pi**2) ) )
    r1EogH.append ( ( (r1**(1-n)) * Ej[j] ) / ( g * Ho ) )        
    tjr1r2.append ( tj[j] * (r1**tj[j]) * (r2**sj[j]) )
    sjr2.append ( sj[j] * (r2**tj[j]) )
    for t in range(len(Theta)):
        #astarD.append ( a_star[t] * Dj[j] )
        aj.append (   ( a_star[t]*Dj[j] * (  ( tj[j] * (r1**tj[j]) * (r2**(1-n)) ) - ( (r2**tj[j]) * (r1**(1-n)) ) ) +  ( r1EogH[j] * r2**tj[j] ) ) / ( (sjr2[j] * (r1**sj[j])) - tjr1r2[j] ) )
        bj.append ( ( -1* a_star[t]*Dj[j] * (  ( sj[j] * (r1**sj[j]) * (r2**(1-n)) ) - ( (r2**sj[j]) * (r1**(1-n)) ) ) -  ( r1EogH[j] * r2**sj[j] ) ) / ( (sjr2[j] * (r2**sj[j])) - tjr1r2[j] ) ) 
        for r in range(len(rr)): 
            zeta[r,t] = zeta[r,t] + ( ( (aj[j] * rr[r]**(sj[j])) + (bj[j] * rr[r]**(tj[j])) ) * (Wo*np.cos( (jj[j]*np.pi*Theta[t])/phi)  +  Wphi*np.cos( (jj[j]*np.pi*(Theta[t]-phi))/phi)) )


x,y = np.meshgrid(Theta, rr)

X = Theta
Y = rr

fig = plt.figure()
ax = fig.add_subplot(111, polar='True')
ax.pcolormesh(X, Y, zeta) #X,Y & data2D must all be same dimensions

ax.set_thetamin(0)
ax.set_thetamax(90)

plot = ax.pcolor(zeta)
fig.colorbar(plot)

plt.show()

我得到的zeta的值太大了。它们应该更像下面的θPI/4解决方案中的值。我知道方程很复杂。我想要的是网格中的一个点，比如r=1000，θ=pi/4，计算j=1，j=2和j=3的zeta值，然后将它们相加，然后在网格中的每个点做相同的事情。我想知道我是否需要改变我的循环结构？或者不使用.append函数？有人有什么建议吗

为θPI/4完成

"""
Plot idealized solution for water levels in a quarter circle domain with 
constant bathymetry  
"""
import numpy as np
import matplotlib.pyplot as plt
#from pylab import meshgrid,cm,imshow,contour,clabel,colorbar,axis,title,show

# establish parameters
Ho = 300 #m
g = 9.81 #m/s2
r1 = 1000 #m
r2 = 10000 #m
rr = np.arange(r1,r2,10)
zeta = [0] * len(rr)
#radial size of domain
phi = np.pi/2
#theta is the angle in radians at a specific location within the domain
theta = np.pi/4

#converting from wind speed to wind shear stress
U = 10
Cd = (1/1000) * ((3/4) + (U/15))
Roair = 1.225 #kg/m3
Rowater = 997 #kg/m3

W = (Roair/Rowater) * Cd * (U**2)

#wind shear in m^2/s^2 in the 0 direction (W to E)
Wo = np.sqrt((W**2)/2)
#wind shear in m^2/s^2 in the phi direction 
Wphi = np.sqrt((W**2)/2)

#determines the bathymetry
n = 0
kappa = (1-n)**(0.5)
a_star = ( (np.sin(phi)) / (g*Ho*kappa* np.sin(kappa*theta)) )

#first half of equation 19 that does not depend on j 
for r in range(len(rr)):
    zeta[r] = ( a_star * (rr[r]**(1-n))*(Wo*np.cos(((1-n)**(0.5))*theta) + Wphi*np.cos(((1-n)**(0.5))*(theta-phi))) ) 

#plt.xlabel("rr")
#plt.ylabel("zeta")
###
#plt.plot(rr,zeta, label = 'LHS eq 19') 

#second half of equation 19 for j=0    
for r in range(len(rr)):
    j = 0
    Djo = np.sin(( ( (1-n)**(0.5) ) * phi ) ) / ( (1-n)**(0.5) * (phi) ) 
    Ejo = (np.sin(phi)) / (phi) 
    ajbj =  (r2**(1-n)) * (-a_star * Djo) 
    zeta[r] = zeta[r] + (ajbj)*(Wo+Wphi) 

#plt.xlabel("rr")
#plt.ylabel("zeta")
###
#plt.plot(rr,zeta, label = 'j=0') 

#second half of equation 19 for j=1,2,3 (summation) 

sj = []
tj = []
Dj = []
Ej = []
r1EogH = []
astarD = []
tjr1r2 = []
sjr2 = []
aj = []
bj = []

jj = [1,2,3]
for j in range(len(jj)):
    sj.append(- (n/2) + np.sqrt( ( (n/2)**2) + ( (jj[j]*np.pi / phi)**2) ) )
    tj.append (- (n/2) - np.sqrt( ( (n/2)**2) + ( (jj[j]*np.pi / phi)**2) ) )    
    Dj.append ( (2* ((-1)**jj[j]) * ((1-n)**(0.5)) * phi * np.sin( ((1-n)**(0.5)) * phi )) / ( (1-n) * (phi**2) - (jj[j]**2) * (np.pi**2) ) )
    Ej.append ( (2* ((-1)**jj[j]) * phi * np.sin(phi) ) / ( (phi**2) - (jj[j]**2) * (np.pi**2) ) )
    r1EogH.append ( ( (r1**(1-n)) * Ej[j] ) / ( g * Ho ) )
    astarD.append ( a_star * Dj[j] )
    tjr1r2.append ( tj[j] * (r1**tj[j]) * (r2**sj[j]) )
    sjr2.append ( sj[j] * (r2**tj[j]) )
    aj.append (   ( astarD[j] * (  ( tj[j] * (r1**tj[j]) * (r2**(1-n)) ) - ( (r2**tj[j]) * (r1**(1-n)) ) ) +  ( r1EogH[j] * r2**tj[j] ) ) / ( sjr2[j] * (r1**sj[j]) - tjr1r2[j] ) )
    bj.append (- ( astarD[j] * (  ( sj[j] * (r1**sj[j]) * (r2**(1-n)) ) - ( (r2**sj[j]) * (r1**(1-n)) ) ) -  ( r1EogH[j] * r2**sj[j] ) ) / ( sjr2[j] * (r2**sj[j]) - tjr1r2[j] ) ) 
    for r in range(len(rr)):
        zeta[r] = zeta[r] + ( ( (aj[j] * rr[r]**(sj[j])) + (bj[j] * rr[r]**(tj[j])) ) * (Wo*np.cos( (jj[j]*np.pi*theta)/phi)  +  Wphi*np.cos( (jj[j]*np.pi*(theta-phi))/phi)) )

plt.xlabel("rr")
plt.ylabel("zeta")
plt.title("Wind In at 45 degrees")
#
plt.plot(rr,zeta, label = 'Ho=100m') 

plt.legend(loc='upper right')

---

不幸的是，我不是一个数学向导。在我尝试以某种方式重构代码之前，我尝试运行您的代码以查看它得到了什么输出。但是，由于所提供的代码段中没有定义来自

sj.append（）

的

sj

之类的内容，因此会出现错误。我不知道如何阅读你图片中提供的等式（数学课程是很多年前的事了，从大学开始就没有使用过）

至于建议，如果没有完全理解你的问题，我能给你的最好的建议是考虑做一些功能。这使您/其他人能够更清楚地看到代码。另一个优点是，当某些内容发生变化时（方程式似乎不太可能发生变化，但您可能希望在将来某个时候更改输入类型），这些变化将以较小的片段进行

def calculate_j(point_or_other_necessary_input):
  """ do the maths for j """
  return some_equation_or_value_for_j

def calculate_t(point_or_other_necessary_input):
  """ do the maths for t """
  return some_equation_or_value_for_t

def calculate_r(point_or_other_necessary_input):
  """ do the maths for r """
  return some_equation_or_value_for_r

def process_grid(zeta_grid):
  """ process each point in the provided grid"""
  for point in zeta_grid:
    # or whatever makes sense to combine the values/equations
    calculated_sum = calculate_j(point) + calculate_t(point) + calculate_r(point)
    # store value in some reasonable way, probably another grid
  return calculated_points

print(process_grid(zeta))

经过进一步评估，以及您编辑的更多信息后，我不得不问您是否真的打算这样做：

jj = [1,2,3]
for j in range(len(jj)):

我猜，没有真正确定，你希望

j

成为

1

然后

2

，然后

3

，不是吗？目前，您确实得到了

0

、

1

、

2

，因为您是在列表的长度上进行迭代，而不是在列表中的项目上进行迭代。这在第一部分中并不重要，在第一部分中，您使用

jj[j]

获得jj的值，但在r部分中，您使用

j

而不是

jj[j]

，例如：

zeta[r] = zeta[r] + ( ( (aj[j] * rr[r]**(sj[j])) + (bj[j] * rr[r]**(tj[j])) )

---

如前所述，这可能是您的预期行为，仅使用0,1,2而不是1,2,3。至于为什么值可能太大，您是否打算计算所有rr 3次的r？您将它嵌套在第一个for循环中，这意味着它将在

for j in…

循环的每个迭代中执行。因此，它在自己身上增加了很多次（

zeta[r]=zeta[r]+…

）。（再说一次，不是数学专业的人）但那不是跑了3次len（rr）还是3次len（rr）？比可能预期的次数多一些

建议编写一个函数zeta（r，t，j），你可以用一些手工计算的值来测试它：

def zeta(r, theta, j):
   #your complex calculations here

assert zeta(4000, pi/4, 2) == 0.00043 #This is a test to be sure your formulae 
                                      # are right (eyeballed from your graph)

然后迭代rr和θ以填充数组：

zeta_out = np.zeros((len(rr), len(Theta)))

for r in range(len(rr)):
    for t in range(len(theta)):
        zeta_out[r, t] = np.mean(zeta(rr[r], theta[t], j) for j in (1,2,3))

---

那代码是无法维护的。每天都有非常复杂的数学运算在Python中执行，但它们看起来不像那样。这个方法需要重新制定，我甚至不能给出建议对不起，只是这不是前进的方向。也许，如果你发布一个带有等式的数字，你可以找到一个好的灵魂来为你重写这个烂摊子。你犯了什么错。我的意思是，如果你想要一个函数编码方面的帮助，发布函数，你可以发布一个具有预期输出的示例，以便更好地理解并帮助你。必须有更好的方法来编写它。是否所有这些未定义的变量都附加到列表或Numpy数组中？代码非常难阅读，即使参考了您的公式，我们也无法运行它，因为它不是一个。问题已更新。如果需要，可以添加更多。谢谢！这是一个很好的开始。对我来说，任何简化的方法都是有帮助的。另外，我在上面添加了我所有的代码，所以希望它是可重复的。请参阅我的编辑。我相信你的一些错误可能是在访问“j”时。如果只使用“j”的值，可以通过直接访问for循环中的值来简化您的生活。i、 e.“对于jj中的j:”