如何使用嵌套循环创建多个文件

Question

我希望每个人在这段时间都很好，安全和健康。 我目前正在做一个 python 作业。使用下面的代码，我需要遍历每个 beta 值，并且对于每个 beta 值，我需要遍历每个 reduce) 因子来运行以下步骤。

然后，对于每个 beta 值的 reductiom_factor 迭代，我需要将数据保存在标题为 listofsolutions 的文件中。有两件事我不知道该怎么做：如何使用解决方案列表中名称的文件导出数据（按 beta 和 reduction_factor 的每个值的顺序排列），以及如何使用 np.savez 保存数据到我刚刚创建的文件。

这是我修改后的代码

   b = [1/4, 0]
   beta = np.asarray(b)
   gamma = 0.5
   listofsolutions = ['Q2_AA_0.1','Q2_AA_0.9','Q2_AA_0.99', 'Q2_AA_1', 'Q2_AA_1.1', 'Q2_AA_2','Q2_CD_0.1','Q2_CD_0.9','Q2_CD_0.99', 'Q2_CD_1', 'Q2_CD_1.1', 'Q2_CD_2']
   consistent = True   # use a consistent mass matrix
   for bb in itertools.zip_longest(beta):
       c = np.sqrt(E / rho_tilde)  # wave speed
       T = 0.016   # total time
# compute the critical time-step
# note: uncondionally stable AA scheme will return 1.0
       delta_t_crit = fe.get_delta_t_crit(le = le, gamma = gamma, beta = bb, consistent = consistent, c = c)
# actual times-step used is a factor of the critical time-step
      reduction_factor = [0.1, 0.9, 0.99, 1, 1.1, 2]
      for rf in reduction_factor:
          delta_t = rf * delta_t_crit
    # selected output data is stored to a file with the name given below
    # use this to save the results from the different runs
    # change the name to match the data you want to store
        for i in b and r in reduction_factor: 
            outfile[i] = listofsolutions[i]
    n_t_steps = int(np.ceil(T / delta_t));    # number of time step
    # initialise the time domain, K and M
    t = np.linspace(0, T, n_t_steps)
    K = np.zeros((n_dof, n_dof))
    M = np.zeros((n_dof, n_dof))

    # assemble K and M
    for ee in range(n_el):
        dof_index = fe.get_dof_index(ee)
        M[np.ix_(dof_index, dof_index)] +=  fe.get_Me(le = le, Ae = Ae, rho_tilde_e = rho_tilde, consistent = consistent)

    # damping matrix
    C = np.zeros((n_dof, n_dof))

    # assemble the system matrix A
    A_matrix = M + (gamma * delta_t) * C + (beta * delta_t**2)*K 

    # define the free dofs
    free_dof = np.arange(1,n_dof)

    # initial conditions
    d = np.zeros((n_dof, 1))
    v = np.zeros((n_dof, 1))
    F = np.zeros((n_dof, 1))

    # compute the initial acceleration
    a = np.linalg.solve(M, F - C.dot(v) - K.dot(d))

    # store the history data 
    # rows -> each node 
    # columns -> each time step including initial at 0
    d_his = np.zeros((n_dof, n_t_steps))
    v_his = np.zeros((n_dof, n_t_steps))
    a_his = np.zeros((n_dof, n_t_steps))
    d_his[:,0] = d[:,0]
    v_his[:,0] = v[:,0]
    a_his[:,0] = a[:,0]

    # loop over the time domain and solve the problem at each step
    for n in range(1,n_t_steps):
        # data at beginning of the time-step n
        a_n = a
        v_n = v
        d_n = d

        # applied loading
        t_current = n * delta_t # current time
        if t_current<0.001:
            F[-1] = A_bar * Ae * np.sin(1000 * t_current * np.pi)
        else:
            F[-1]=0.

        # define predictors
        d_tilde = d_n + delta_t*v_n + ((delta_t**2)/2.) * (1 - 2*beta) * a_n
        v_tilde = v_n + (1 - gamma) * delta_t * a_n

        # assemble the right-hand side from the known data
        R = F - C.dot(v_tilde) - K.dot(d_tilde)

        # impose essential boundary condition and solve A a = RHS
        A_free = A_matrix[np.ix_(free_dof, free_dof)]
        R_free = R[np.ix_(free_dof)]

        # solve for the accelerations at the free nodes
        a_free = np.linalg.solve(A_free, R_free) 
        a = np.zeros((n_dof, 1))
        a[1:] = a_free

        # update displacement and vecloity predictors using the acceleration
        d = d_tilde + (beta * delta_t**2) * a
        v = v_tilde + (gamma * delta_t) * a

        # store solutions
        d_his[:,n] = d[:,0]
        v_his[:,n] = v[:,0]
        a_his[:,n] = a[:,0]

    # post-processing
    mid_node = int(np.ceil(n_dof / 2))  # mid node

    # compute the stress in each element
    # assuming constant E
    stress = (E / le) * np.diff(d_his, axis=0)

    # here we save the stress data for the middle element

    np.savez(outfile, t, stress[mid_node,:]

我不确定如何指定程序以保存 gamma 中每个 reduction_factor 值的结果。此外，对于代码的最后一行，我不确定如何将每次迭代保存到我创建的文件名列表中。

我尝试使用语句“来做到这一点”

for i in b` and r in reduction_factor: 
                outfile[i] = listofsolutions[i]"` 

但我认为这没有意义。

我是 python 的新手，所以我不熟悉如何在嵌套循环中保存文件。如果我的任何问题是初步的，我深表歉意。

Answer 1

    for i in b and r in reduction_factor: 
        outfile[i] = listofsolutions[i]

这是不正确的。可能的解决方案：

for i in b: # variable 'i' will take every value of list b
    for r in reduction_factor:  # 'r' will iterate through reduction_factor 
        outfile[i] = listofsolutions[i]  # outfile must be declared until it 

仍然没有逻辑。这样，您可以创建字典。 如果您真的想创建文件 - 请阅读“with open(filename, 'w'):”构造和嵌套循环或列表理解。