# Twoj kod ....
for i in range(4 * N):
Rhs[bcnodesAll[i]] = bvals[i]
# Time loop
Results = list()
Results.append(np.array(Rhs.reshape((N, N))))
for iter in range(NTimeSteps):
print 'time iteration:', iter + 1
sol = solve(EqMat, Rhs)
if sol[1] != 0:
print "solution is not converged"
T = np.array(sol[0])
# Zaktualizuj wektor prawych stron
Rhs = T
# Zapisz rozwiazania w liscie, na skonwertuj wyniki z wektora na tablice 2D
# T = ... twoj kod ..
T = np.reshape(T, (N, N))
Results.append(T)
print("\n--- %s seconds ---" % (time.time() - start_time))
# Animate results:
animate_contour_plot(Results, skip=20, repeat=True)
# Zadaj warunki brzegowe i poczatkowe w wektorze prawych stron (skorzystaj z tablic bvals i bcnodes)
# Twoj kod ....
for i in range(4 * N):
Rhs[bcnodesAll[i]] = bvals[i]
#Tworzymy zbior rozwiazan
Results = list()
#Dodajemy pierwsze rozwiazanie
Results.append(np.array(Rhs.reshape((N, N))))
# Petla czasowa
for iter in range(NTimeSteps):
print 'time iteration:', iter + 1
#T = ... rozwiaz rownanie
T = np.linalg.solve(EqMatrix, Rhs)
# Zaktualizuj wektor prawych stron
#Rhs = ....
Rhs = T
#Zapisz rozwiazania w liscie, na skonwertuj wyniki z wektora na tablice 2D
# T = ... twoj kod ..
T = np.reshape(T, (N, N))
Results.append(T)
print("\n--- %s seconds ---" % (time.time() - start_time))
# Wyswietl wyniki:
animate_contour_plot(Results, skip=5, repeat=True)
K[d_id(K,1)]=1
# Diagonala odnoszaca sie do wezlow T[i,j+1]
K[d_id(K,N)]=1
print(K)
# Zmodyfikuj rownania w macierzy tak, aby jawnie wprowadzic rozwiazania dla wezlow brzegowych (odwolaj sie do
# indeksow za pomoca tablicy bcnodesAll)
for i in bcnodes:
K[bcnodesAll,:]=0
K[bcnodesAll,bcnodesAll]=1
print(K)
# Utworz wektor prawych stron rownania
Rhs = np.zeros(N**2)
# Zadaj warunki brzegowe w wektorze prawych stron (skorzystaj z tablic bvals i bcnodes)
for wartosc_na_brzegu, ind_wezl_brzegu in zip(bvals,bcnodes):
Rhs[ind_wezl_brzegu] = wartosc_na_brzegu
print(Rhs)
# Rozwiaz rownanie
T = np.array( solve(K, Rhs) )
# Rebuild T to 2D array
T = T.reshape((N,N))
print("\n"+"T")
print(T)
# Plot result
animate_contour_plot([T])
K[d_id(K, 1)] = 1
# Diagonala odnoszaca sie do wezlow T[i,j+1]
K[d_id(K, N)] = 1
print(K)
# Zmodyfikuj rownania w macierzy tak, aby jawnie wprowadzic rozwiazania dla wezlow brzegowych (odwolaj sie do
# indeksow za pomoca tablicy bcnodesAll)
for i in bcnodes:
K[bcnodesAll, :] = 0
K[bcnodesAll, bcnodesAll] = 1
print(K)
# Utworz wektor prawych stron rownania
Rhs = np.zeros(N**2)
# Zadaj warunki brzegowe w wektorze prawych stron (skorzystaj z tablic bvals i bcnodes)
for wartosc_na_brzegu, ind_wezl_brzegu in zip(bvals, bcnodes):
Rhs[ind_wezl_brzegu] = wartosc_na_brzegu
print(Rhs)
# Rozwiaz rownanie
T = np.array(solve(K, Rhs))
# Rebuild T to 2D array
T = T.reshape((N, N))
print("\n" + "T")
print(T)
# Plot result
animate_contour_plot([T])
time = np.linspace(0, 1, int(1./dt + 1))
forward = range(2,N)
backward = range(0,N-2)
c = a*dt/delta**2
#time loop
for t in time:
print "time:",t
#Equation for new time solution - explicite euler sheme:
# (Tn - T0)/dt -a*laplacian(T0)=0
# Tn = T0 + a*dt*laplacian(T0)
# Tn = T0 + (a*dt/dx**2)*(T0(i,j+1) + T0(i+1,j) - 4*T0(i,j) + T0(i-1,j) + T0(i,j-1) )
#Loop form
# for j in range(1, N-1):
# for i in range(1,N-1):
# T[i,j] += c * ( T[i,j+1] + T[i+1,j] - 4*T[i,j] + T[i-1,j] + T[i,j-1])
#Vecotrized code
T[1:-1,1:-1] = T[1:-1,1:-1] + c*(T[1:-1,forward] + T[forward,1:-1] - 4*T[1:-1,1:-1] + T[backward,1:-1] + T[1:-1,backward])
Results.append(np.copy(T))
# Animate results:
animate_contour_plot(Results, skip=100)
print "calculating time :",t
# (T - T0)/dt -a*laplacian(T0)=0
# T = T0 + a*dt*laplacian(T0)
# T = T0 + (a*dt/dx**2)*(T0(i,j+1) + T0(i+1,j) - 4*T0(i,j) + T0(i-1,j) + T0(i,j-1) )
# Pamietaj, ze na brzegach jest zadany waruenek typu Dirichleta, zatem w tych wezlach
# wartosci nie powinny sie zmieniac
# Twoj kod ....
# for j in range(1,N-1):
# for i in range(1,N-1):
# T[i][j] = T0[i][j] + (a*dt/delta**2)*(T0[i][j+1] + T0[i+1][j] - 4*T0[i][j] + T0[i-1][j] + T0[i][j-1])
backward = range(0,N-2)
forward = range(2,N)
T[1:-1,1:-1] = T0[1:-1,1:-1] + c*(T0[backward,1:-1] + T0[1:-1,backward] - 4*T0[1:-1,1:-1] + T0[1:-1,forward] + T0[forward,1:-1])
T0 = np.copy(T)
Results.append(T0)
# Animate results:
# Wywolaj funkcje z zadania 1, tak aby wyswietlic animacje rozkladu temperatury
animate_contour_plot(Results, skip=20, nLevels= 20)
time = np.linspace(0, endTime, int(endTime / dt + 1))
#time loop
T0 = np.copy(T)
for t in time:
print "calculating time :", t
#Zaimplementuj funkcje obliczajaca jeden krok czasowy zgodnie z poniższym wzorem:
# (T - T0)/dt -a*laplacian(T0)=0
# T = T0 + a*dt*laplacian(T0)
# T = T0 + (a*dt/dx**2)*(T0(i,j+1) + T0(i+1,j) - 4*T0(i,j) + T0(i-1,j) + T0(i,j-1) )
# Pamietaj, ze na brzegach jest zadany waruenek typu Dirichleta, zatem w tych wezlach
# wartosci nie powinny sie zmieniac
c = a * dt / delta**2
for j in range(1, N - 1):
for i in range(1, N - 1):
T[i,
j] = T0[i, j] + c * (T0[i + 1, j] + T0[i, j + 1] - 4 * T[i, j] +
T0[i - 1, j] + T0[i, j - 1])
T0 = np.copy(T)
Results.append(T0)
# Animate results:
# Wywolaj funkcje z zadania 1, tak aby wyswietlic animacje rozkladu temperatury
animate_contour_plot(Results, skip=20)
