Суммирование с помощью вложенных циклов и почтовый

Question

У меня есть файл: volume_FREQ.dat:

# Volume (V) FREQ mode 
18.1   400.9 1  #| 
18.1   401.3 2  #| 1st Volume: 18.1 
18.1   404.2 3  #| 
18.1   505.2 4  #| 
19.2   202.4 1   #| 
19.2   203.6 2   #| 2nd Volume: 19.2 
19.2   205.4 3   #| 
19.2   199.5 4   #| 

В реальном файле есть 11 томов, и 45 режимов на каждом томе.

Тогда у меня есть этот файл: parameters.dat:

# c   d   f  mode 
-1.14  -24.70  1297.20  1 
-1.24  -22.60  1295.20  2 
-1.54  -21.08  1296.20  3 
-1.72  -22.4  1298.40  4   

Для каждого из этих 11 томов, есть значение P. В следующей формуле, это представлено P(V): Это значение P на каждом Volume рассчитывается путем суммирования по modes, используя значения из c, d, f и FREQ соответственно:

^{Рисунок 1.}

переменная T этот список:

T = [10.0, 30.1, 50.2] 

Реальный список имеет длину 100

Для каждого T и каждый V есть значение P.

Окончательное решение будет в конечном итоге с файлом, как data.dat:

# Volume (V) FREQ mode T  P 
18.1   400.9 1 10.0  x   #| 
18.1   401.3 2 10.0  x   #| 1st Volume: 18.1 
18.1   404.2 3 10.0  x   #| 
18.1   505.2 4 10.0  x   #| 
19.2   202.4 1 10.0  x    #| 
19.2   203.6 2 10.0  x    #| 2nd Volume: 19.2 
19.2   205.4 3 10.0  x    #| 
19.2   199.5 4 10.0  x    #| 
18.1   400.9 1 30.1  x   #| 
18.1   401.3 2 30.1  x   #| 1st Volume: 18.1 
18.1   404.2 3 30.1  x   #| 
18.1   505.2 4 30.1  x   #| 
19.2   202.4 1 30.1  x    #| 
19.2   203.6 2 30.1  x    #| 2nd Volume: 19.2 
19.2   205.4 3 30.1  x    #| 
19.2   199.5 4 30.1  x    #| 
18.1   300.1 1 50.2  x   #| 
18.1   305.2 2 50.2  x   #| 1st Volume: 18.1 
18.1   303.6 3 50.2  x   #| 
18.1   303.9 4 50.2  x   #| 
19.2   304.5 1 50.2  x    #| 
19.2   305.9 2 50.2  x    #| 2nd Volume: 19.2 
19.2   306.5 3 50.2  x    #| 
19.2   307.1 4 50.2  x    #| 

Каждый из входных переменных могут быть легко извлечены с помощью numpy:

import numpy as np 
c, d, f, mode = np.loadtxt('parameters.dat', skiprows = 1).T 
V, FREQ, mode = np.loadtxt('Volume_FREQ.dat', skiprows = 1).T 

Однако трудность возникает, когда применяя формулу и петлю над modes:

Я могу создать список VOLUME :

VOLUME = [19.2, 18.1] 

А потом вложенный цикл + zip:

sum_for_each_volume = [] 
for i_VOLUME in VOLUME: 

    P_CORRECT = [] 

    for j_c1, j_d, j_FREQ, i_T in zip(c1, d, FREQ, T): 

     P = j_FREQ * i_T * (i_VOLUME * j_c1 + j_d) 

     P_CORRECT.append(P) 

    summation = sum(P_CORRECT) 

    sum_for_each_volume.append(summation) 

Однако это решение не захватывая FREQS на каждом томе правильно, а также все T элементы не считываются каждым volume ,

Буду признателен, если вы поможете мне.

на основе @ user7138814 «s ответ:

Запуск этого сценария:

import numpy as np 
n_volume = 2 
n_mode = 4 
n_T = 3 

c, d, f, mode = np.loadtxt('parameters.dat', skiprows = 1).T 
V, FREQ, mode = np.loadtxt('Volume_FREQ.dat', skiprows = 1).T 
T = [10.0, 30.1, 50.2] 

V = V.reshape(n_volume, n_mode) 
FREQ = FREQ.reshape(n_volume, n_mode) 


P_for_each_volume_and_each_T = [] 

for i in range(n_volume): 
    for j in range(n_T): 
    P = 0 
    for k in range(n_mode) 
     P += FREQ[i,k] * T[j] * (V[i,k]*c[k] + d[k]) 
    P_for_each_volume_and_each_T.append(P) 


print 'P = ', P_for_each_volume_and_each_T 

выход заключается в следующем:

P = [-830821.31000000006, -2500772.1431000005, -4170722.9762000004, -403382.67200000002, -1214181.8427200001, -2024981.0134400004]

Однако с помощью P_for_each_volume_and_each_T[i] = P_for_each_volume_and_each_T[i] + P_for_each_volume_and_each_T[i-1]стратегия, как показано на рисунке h ERE (запустите скрипт):

import numpy as np 

n_volume = 2 
n_mode = 4 

n_T = 3 

c, d, f, mode = np.loadtxt('parameters.dat', skiprows = 1).T 
V, FREQ, mode = np.loadtxt('Volume_FREQ.dat', skiprows = 1).T 
T = [10.0, 30.1, 50.2] 

V = V.reshape(n_volume, n_mode) 
FREQ = FREQ.reshape(n_volume, n_mode) 


P_for_each_volume_and_each_T = [] 

for i in range(n_volume): 

    for j in range(n_T): 
    P = 0 
    for k in range(n_mode): 
     P = FREQ[i,k] * T[j] * (V[i,k]*c[k] + d[k]) 
     print 'FREQ[i,k] = ', FREQ[i,k] 
     print 'V[i,k] = ', V[i,k] 
     print 'c[k] = ', c[k] 
     print 'd[k] = ', d[k] 
     print 'P = ', P 
    P_for_each_volume_and_each_T.append(P) 
print 'P = ', P_for_each_volume_and_each_T 


for i in xrange(1,len(P_for_each_volume_and_each_T)): 
    P_for_each_volume_and_each_T[i] = P_for_each_volume_and_each_T[i] + P_for_each_volume_and_each_T[i-1] 


print 'P after summing= ', P_for_each_volume_and_each_T 

вы получите этот результат:

P = [-270443.66399999999, -814035.42863999994, -1357627.19328, -110570.88, -332818.34880000004, -555065.81760000007]

это делает общий смысл при подведении:

P after summing= [-270443.66399999999, -1084479.0926399999, -2442106.2859199997, -2552677.1659199996, -2885495.5147199994, -3440561.3323199996]

Поэтому P after summing список делает не соответствует @ user7138814P.

Какая стратегия является поэтому правильной для решения этой проблемы (см. Рисунок 1)?

Либо +=стратегия или [i] + [i-1]стратегия?

Answer 1

Вам нужен еще один цикл for, поскольку у вас есть массивы из 3-х разных длин (т. Е. Пространство параметров 3-мерное). V и FREQ, которые вы загружаете с volume_FREQ.dat, фактически являются двумерными данными. Таким образом, с перекраивает и другой цикл, вы получите что-то вроде:

import numpy as np 

n_volume = 11 
n_mode = 45 
n_T = 3 

c, d, f, mode = np.loadtxt('parameters.dat', skiprows = 1).T 
V, FREQ, mode = np.loadtxt('Volume_FREQ.dat', skiprows = 1).T 
T = [10.0, 30.1, 50.2] 

V = V.reshape(n_volume, n_mode) 
FREQ = FREQ.reshape(n_volume, n_mode) 

P_for_each_volume_and_each_T = [] 
for i in range(n_volume): 
    for j in range(n_T): 
     P = 0 
     for k in range(n_mode) 
      P += FREQ[i,k] * T[j] * (V[i,k]*c[k] + d[k]) 
     P_for_each_volume_and_each_T.append(P) 

Более numpythonic будет следующей операции массива:

V = V.reshape(n_volume, n_mode) 
FREQ = FREQ.reshape(n_volume, n_mode) 
T = np.array(T).reshape(-1, 1, 1) 
P_for_each_volume_and_each_T = (FREQ * T * (V*c + d)).sum(axis=0) 

Это даст (n_volume, n_T) 2D массив. Используйте ravel, чтобы получить тот же результат, что и для for-loops.