Question

代码在中间停止。请帮忙在获取所有输入后，代码在计算计算部分时停止

i=float(input(print('enter the number of nodes')))
T0=float(input(print('Enter the first boundary condition')))
Tn=float(input(print('Enter the second boundary condition')))
a=float(input(print('Enter the Thermal cunductivity value')))
Ti=float(input(print('Enter the initial condition')))
n=float(input(print('Enter the number of time steps')))
dt=float(input(print('Enter the change in time dt')))
k=0
T=[]
T.append(T0)
while k!=i:
    T.append(Ti)
    k+=1
T.append(Tn)
print(T)
k=0
dx=1/(i+1)
while k!=n:
    j=0
    while j!=len(T):
        y=(a*dt/(dx**2))*(T[j-1]+T[j+1])+(1-2*((a*dt)/(dx**2)))*T[j]
        T.append(y)
        j+=1
    print(T)
    k+=1

Answer 1

我不知道是不是原因，但在条件中使用<local:OutlinedTextBlock FontFamily="Verdana" FontSize="28pt" FontWeight="ExtraBold" TextWrapping="Wrap" StrokeThickness="1" Stroke="Black" Fill="White"> Text </local:OutlinedTextBlock>时，请不要使用floats。相反，请使用!=。实际上，0.000001的差异足以让您的情况永远不会成为现实，而在您的代码中，您大多数步骤为1.0。

因此，如果您的输入<=不是圆的，那么您的第一个i循环将永远运行。

Answer 2

让我们使用一些简单的Python功能重写您的代码。（我将在明年留下高级功能。; - ）

首先，要知道整数和浮点数之间的区别。如果你希望有一个小数点并做精确的数学运算，你可以使用浮点数。编程的一部分是尝试很难不使用浮点数，除非你必须 - 浮点数占用更多的空间，并且它们使你的程序在99％的时间内运行得更慢。

其次，raw_input([prompt])需要一个字符串作为提示。不需要print。（这在Python 3中变为input()。）所以：

i=float(input(print('enter the number of nodes')))
T0=float(input(print('Enter the first boundary condition')))
Tn=float(input(print('Enter the second boundary condition')))
a=float(input(print('Enter the Thermal cunductivity value')))
Ti=float(input(print('Enter the initial condition')))
n=float(input(print('Enter the number of time steps')))
dt=float(input(print('Enter the change in time dt')))

变为：

num_nodes = int(input("Enter the number of nodes: "))
boundary1 = float(input("Enter the first boundary condition: "))
boundary2 = float(input("Enter the second boundary condition: "))
conductivity = float(input("Enter the thermal conductivity: "))
initial_cond = float(input("Enter the initial condition: "))
num_ticks = int(input("Enter the number of time steps: "))
delta_t = float(input("Enter the change in time, dT: "))

现在，让我们初始化一些东西：

k=0
T=[]
T.append(T0)
while k!=i:
    T.append(Ti)
    k+=1
T.append(Tn)
print(T)
k=0

从这段代码中，k=0到k=0告诉我k只是用作循环计数器。循环只是将相同的值反复添加到T列表中。此外，您正在使用T=[]，然后立即T.append(T0)。 Python已经为这些东西提供了很酷的语法。但是T列表是什么？此外，边界是否与节点数量相关？他们应该吗？

T = ( [boundary1] 
    + [initial_cond] * num_nodes 
    + [boundary2]
    )

现在我们来看代码的最后一部分：

k=0
dx=1/(i+1)
while k!=n:
    j=0
    while j!=len(T):
        y=(a*dt/(dx**2))*(T[j-1]+T[j+1])+(1-2*((a*dt)/(dx**2)))*T[j]
        T.append(y)
        j+=1
    print(T)
    k+=1

再次使用k作为循环计数器！还有一种Pythonic方式，但让我们看看循环内部，我们看到j也用作循环计数器。但至少j被重新用作索引！我们也有索引的成语。

在Python中，当你想循环一些次时，你可以使用range([start=0], stop, [step=1])。默认情况下，您获得值0 .. n-1。

time_sec = 0.0
for t in range(num_ticks):
    time_sec += delta_t

现在，让我们看看dx。我看到你在这里定义它：

dx=1/(i+1)

你在这里使用它：

y=(a*dt/(dx**2))*(T[j-1]+T[j+1])+(1-2*((a*dt)/(dx**2)))*T[j]

这就是全部。但是如果我们拆开那个公式，并添加一组parens来处理换行符和一些空格，我们就会得到这个：

y = (
              ( a*dt /(dx**2))   * (T[j-1] + T[j+1])
    +(1 - 2 * ((a*dt)/(dx**2)) ) * T[j]
    )

您不使用dx而不使用a*dt/dx**2。因此，让我们摆脱dx并用更大的计算代替它！

adt_per_dx2 = a * dt / (1 / (i+1)) ** 2

哪些因素：

adt_per_dx2 = a * dt * (i+1)**2

您确定该公式吗？

无论如何，它将数学改为：

y = adt_per_dx2 * (T[j-1] + T[j+2]) + (1 - 2 * adt_per_dx2) * T[j]

我认为是：

y = T[j] + (T[j-1] - T[j]) * adt_per_dx2 + (T[j+1] - T[j]) * adt_per_dx2

我想回到这一点，因为我们可以用它进行优化。（还记得当我说浮点运算很昂贵吗？）

让我们暂停一下，看看T。当你开始时，我认为T看起来像是一种物质。＆＃34;也就是说，它看起来有一个边界，然后是一些内部节点，然后是另一个边界。几乎就像你在整个厚度的不同点对一块材料的温度进行建模。

然后你附加到T列表。哪种材料更厚？或者只是意味着你有一个错误，你应该替换值而不是附加到列表的末尾。

我会尝试更换价值观。如果我弄错了你可以告诉我。（我在这里猜测，你正在尝试做什么。）

另外，请考虑一下：

lst = [1,2,3]
index = 0
print(lst[index-1] + lst[index] + lst[index+1])

如果您将其提供给Python，那么您将获得6。为什么呢？

因为lst[-1]从列表中提取最后一项！特殊的魔术Python语法！在这种情况下，可能不是你想要的。在这种情况下，我认为您不希望范围从0到len(T)。相反，您希望跨越内部节点并且仅保留边界。（或者，也许你想在边界之外添加一些其他值。你必须告诉我。）

因此我们只需要处理内部节点，并忽略边界。幸运的是，range()函数采用 start 参数！但要记住它没有停止 stop 参数。在这种情况下，我们需要添加一个：

T_new = T[:] # Make a copy of T

for j in range(1, num_nodes+1):
    T_new[j] = ( T[j] 
           + (T[j-1] - T[j]) * adt_per_dx2 
           + (T[j+1] - T[j]) * adt_per_dx2
           )
T = T_new   # Replace the old T with the new T.

我做了T vs. T_new事情，因此计算中间结果不会影响减法（T [j-1] - T [j]）。

现在，让我们进行一点优化。注意j正在增加？所以在循环＆＃39; N＆＃39;，我们有T [j + 1]。但是在循环N + 1上将是T [j]！如果我们不介意改变标志，我们可以保存一些中间结果。也就是说，T[j+1] - T[j]最终将成为T[j] - T[j-1]。如果我们只是否定它，它将是T[j-1] - T[j]，我们想要保留它！

更重要的是，如果我们可以保存这些计算，我们就不再需要T_new了，因为T_new的唯一原因是因为T[j-1]得到了T[j]在我们使用它来计算T[j+1] - T[j]之前更新。

让我们尝试保存saved = T[1] - T[0] for j in range(1, num_nodes+1): T[j] = (T[j] + -saved * adt_per_dx2 + (T[j+1] - T[j]) * adt_per_dx2 ) saved = T[j+1] - T[j]计算，并否定它。

T_new

好的，这有点儿了。它摆脱了saved = (T[1] - T[0]) * adt_per_dx2 for j in range(1, num_items+1): temp = (T[j+1] - T[j]) * adt_per_dx2 T[j] += temp - saved saved = temp变量。我们可以做更多吗？让我们再添加一个临时变量，然后乘以：

print("Time={}s, T={}r\n".format(time_sec, T))

让我们用当前的T阵列打印时间：

num_nodes = int(input("Enter the number of nodes: "))
boundary1 = float(input("Enter the first boundary condition: "))
boundary2 = float(input("Enter the second boundary condition: "))
conductivity = float(input("Enter the thermal conductivity: "))
initial_cond = float(input("Enter the initial condition: "))
num_ticks = int(input("Enter the number of time steps: "))
delta_t = float(input("Enter the change in time, dT: "))

T = ( [boundary1]
    + [initial_cond] * num_nodes
    + [boundary2]
    )

adt_per_dx2 = conductivity * delta_t * (num_nodes + 1)**2

time_sec = 0.0
for t in range(num_ticks):
    time_sec += delta_t

    saved = (T[1] - T[0]) * adt_per_dx2

    for j in range(1, num_nodes+1):
        temp = (T[j+1] - T[j]) * adt_per_dx2
        T[j] += temp - saved
        saved = temp

    print("Time={}s, T={}r\n".format(time_sec, T))

全部放在一起：

{{1}}

现在，当我运行它时，问题就出现了。我认为＆＃34; adt_per_dx2＆＃34;应该小于1。但事实并非如此。这意味着节点之间的delta-T增加，并且增加的数量增加到T [j]。我知道这是错误的，因为你无法从无处获得自由热。

但这是我实际上不知道你在做什么的部分。所以我不知道错误在哪里。我认为它与节点数有关，也许你应该要求总长度或厚度除以节点数？无论如何，检查一下，看看你做了什么。

程序没有运行

2 个答案: